精华内容
下载资源
问答
  • Java语言程序设计(基础篇)》读书笔记(二)
    2021-03-03 11:49:18

    《Java语言程序设计(基础篇)》读书笔记(二)

    转载请注明出处

    如果觉得文章对你有所帮助,请通过留言或关注微信公众帐号wangzzstrive来支持我,谢谢!

    书接上回,进入到重点章节。

    第八章 对象和类

    1、类方法

    Java中用static关键字标识类方法,而在Objective-C中用加号(+)标识类方法;

    需要说明的是,可运行类中的main方法必须是定义成public static void型的静态方法。

    2、构造方法

    构造方法具有以下特点:

    ①方法名必须和类名相同

    形式如下:

    public ClassName(arguments) {

    //init

    }

    ②没有返回类型

    甚至连void类型都没有,一种常见的错误是:

    public void ClassName() {

    }

    ③构造方法可以有若干个

    同时有多个方法,在技术叫重载,同样也可以重载构造方法;

    重载时除了遵守方法名和类名相同的规则以外,还要保证方法签名不同(只能通过给构造方法增加不同的参数来保证);

    构造方法有多个就意味着我们可以通过多种方式创建一个对象;

    所谓的若干,就是可以有多个,也可以一个都没有,就是说类也可以不定义构造方法,在这种情况下,编译器会生成一个隐藏的无参构造方法,注意是仅在我们没显示定义构造方法的情况下才生成。

    ④构造方法是实例方法

    从构造方法的声明方式上不难看出这一点,之所以将其单列一条,是因为在Objective-C中可以通过两段构造法:先是类方法alloc来为对象分配内存,再通过实例方法init来初始化生成的对象(当然也支持直接使用类方法new来一步实现初始化对象),我实在好奇Java是如何通过实例方法直接初始化对象的!

    ⑤父类构造方法无法被子类继承

    不像属性和方法,父类的构造方法是不能被子类继承的,它们只能从子类的构造方法中通过后文讲到的super关键字调用!这也是有别于Objective-C的一点。

    第九章 字符串和文本I/O

    1、字符串

    Java中的字符串使用非基本类型变量String表示,它Objective-C中的NSString类功能相似。

    需要说明的是,因为字符串是不可变的,但同时又会频繁地使用,所以Java虚拟机为了提高效率和节约内存,对具有相同字符串序列的字符串直接使用同一个实例,这是种在Cocoa中被称为享元模式的设计模式,Objective-C中的很多类比如NSString,NSNumber等都使用了这种模式

    第十章 关于对象的思考

    1、this引用

    主要有两个作用:

    ①指代当前对象

    Java以及很多语言中都有的关键字this和Objective-C中的关键字self非常相似,都用于指代当前对象

    ②让构造方法调用同一个类的另一个构造方法

    这是Java中this比较特殊的用法。前面讲过构造方法也是可以重载的,当有多个构造方法的时候,通常无参数或者参数少的构造方法可以用this(参数列表)的方式调用参数多的构造方法。这跟Objective-C中指定初始化方法的设计原则很像,使用参数列表最多的作为指定初始化方法,其它参数较少的称为辅助初始化方法,辅助初始化方法通过调用指定初始化方法,并未没有显示要求的参数传入默认值来完成初始化操作。这样做可以简化代码,使类易于阅读和维护。以书上的Circle类为例:

    public class Circle {

    private double radius;

    //指定构造方法

    public Circle(double radius) {

    this.radius = radius;

    }

    //辅助构造方法

    public Circle () {

    this(1.0);//通过this调用参数较多的指定构造方法

    }

    }

    第十一章 继承和多态

    1、Java不支持多继承

    和Objective-C一样,Java是不支持多继承的。

    ①Java和Objective-C多继承折中方案

    Objective-C可以通过委托、协议、运行时消息分发等机制来弥补这个不足;

    Java可以通过接口实现多继承,关于接口14章中会详细介绍。

    ②Java中接口和Objective-C中协议的异同

    相同点:

    我理解的Java中的接口有点像Objective-C中的协议,它们都是为了定义一种类所具有的能力,都是为了使方法从某些具有相同能力的、具体的类中抽象出来;

    不同点:

    二者有本质的区别,Objective-C中的协议充其量只是一个方法集合,而Java中的接口却是特殊的抽象类,其本质是类!

    2、super关键字

    类似Objective-C中的super关键字,Java中的super也是指向当前类的父类,它的特殊用法是用于调用父类的构造方法

    前面讲过,super是显示调用父类构造方法的唯一方式,而且这个调用必须是子类构造方法的第一条语句,如下所示:

    public Circle2 (double radius, boolean filled) {

    super(filled);//调用父类的构造方法,必须放在子类构造方法的第一句

    this.radius = radius;

    }

    3、类继承中的构造方法链

    在任何情况下,构造一个类的实例时,将会调用沿着继承链的所有父类的构造方法,这就是构造方法链。关于构造方法链有以下说明:

    ①自动调用父类无参构造方法

    当前类的构造方法需要调用重载的构造方法或者父类的构造方法,如果二者都没有显示调用,编译器会自动将super()作为当前构造方法的第一条语句,来调用父类的无参构造方法,比如:

    public ClassName() {

    //some statements

    }

    等价于:

    public ClassName() {

    super();

    //some statements

    }

    再强调一遍,只会自动调用父类的无参构造方法!

    ②编译器会为没有显式定义构造方法的类自动生成隐式的无参构造方法

    注意这句话的前提是当前类没有显式定义构造方法!

    ③要为每个类提供一个无参构造方法

    结合前面的①、②两条,不难解释本条。举例说明:

    public class Apple extends Fruit {

    }

    class Fruit {

    public Fruit(String name) {

    System.out.println("Fruit's constructor is invoked.");

    }

    }

    实例化Apple对象时,由于在Apple中没有显示定义构造方法,因此,编译器为Apple生成的隐式默认无参构造方法会被调用。因为Apple是Fruit的子类,Apple的默认构造方法会自动调用Fruit的无参构造方法。然而Fruit中显示定义了重载的构造方法,编译器就不会自动为其生成无参构造方法,这样就会导致程序编译错误!

    总之,出现问题的原因是Fruit类没有定义无参构造方法。

    因此,如果一个类要设计成扩展的,最好提供一个无参构造方法以避免程序设计错误,

    4、覆盖方法

    子类可以从父类中继承方法,但有时子类需要修改父类中方法的实现,这就叫方法的覆盖。关于方法覆盖有几点需要注意:

    ①覆盖父类的方法有时需要调用父类的方法,可以通过super.被覆盖方法名的方式实现,如下:

    public class Circle4 extends GeometricObject {

    //other methods are omitted

    /**Override the toString method defined in GeometricObject*/

    public String toString() {

    return super.toString + "\nradius is" + radius;

    }

    }

    ②仅当实例方法是可访问时,它才能被覆盖

    因为私有方法在它的类本身以外是不能访问的,所以它不能被覆盖。如果子类中定义的方法在父类中是私有的,那这两个方法就没有任何关系。

    ③静态方法不能被覆盖

    和实例方法一样,静态方法也能被继承,但不同的是它不能被覆盖。如果父类中定义的静态方法在子类中被重新定义,那么在父类中的静态方法将被隐藏。可以使用语法:父类名.静态方法名来调用隐藏的父类静态方法。

    ④Java中的覆盖和Objective-C中的重载

    Objective-C中的方法重载(又叫重写)和紧接着要讲的Java方法重载意义不同,却和Java中的方法覆盖差不多。

    5、重载方法

    重载方法意味着可以定义多个同名的方法,但这些方法需要具有不同的方法签名。

    重载和覆盖的区别:

    ①覆盖对应的两个方法名和方法签名均相同;重载对应的两个方法名相同,但方法签名不同

    ②覆盖对应的两个方法一个在子类中,一个在父类中;重载对应的两个方法可能都在子类,也可能一个在子类一个在父类。

    6、Java的根类Object和他的toString()方法

    ①Object类

    Java中的每个类都源自java.lang.Object类,如果定义一个类时没有指定继承性,那么这个类的父类就被默认为是Object。

    Java中的Object类和Objective-C中的NSObject类相似。

    ②toString()方法

    该方法是Object类的实例方法,会返回一个描述该对象的字符串;

    Java中Object的toString()方法和Objective-C中NSObject中的实例方法- (NSString*)description功能相似。

    7、动态绑定

    ①声明类型

    一个变量必须被声明成某种类型,变量的这个类型称为它的声明类型

    ②实际类型

    变量的实际类型是变量引用对象的实际数据类型

    这里想说明的是,变量的声明类型决定了编译时匹配那种类型,用于编译器检查语法错误,而运行时会将该变量作为实际类型来使用,变量类型检查放到运行时进行,这也是判断一门语言是不是动态语言最最根本的标准!!!众所周知,静态语言的变量类型检查是在编译阶段就完成的。

    8、对象类型判断

    Java语言的动态性,使得一个对象可能并不是它实际声明的类型,判断一个对象的真实类型可以通过java关键字instanceof实现。

    该关键字和Objective-C中NSObject的实例方法:- (BOOL)isKindOfClass:(Class)aClass功能相似。

    注意Java是通过关键字来实现,Objective-C是通过NSObject实例方法来实现的。

    9、数据和方法的可见性

    见下图所示:

    47cc14aa9121f97ffc25deea506d9926.png

    10、防止扩散和覆盖

    ①终极类

    有时候可能希望防止类扩展,在这种情况下可以使用final修饰符表明一个类是终极的,比如Java中的Math就是一个终极类,是不能作为父类的。终极类声明方式如下:

    public final class ClassName {

    }

    ②终极方法

    也可以将方法定义为终极的,一个终极方法是不能被它的子类覆盖的。终极方法声明方式如下:

    public class ClassName {

    //Data fields ,constructors and methods omitted

    public final void foo {

    }

    }

    ③终极变量

    变量也可以定义为终极的,结果是其就成了常量。

    好吧,都快一点了,明天还要上班,抓紧睡觉

    未完待续。。。

    更多相关内容
  • 第一章 Java程序设计概述 1.1 java程序设计平台 1.2 java"白皮书"的关键

    【读书笔记罢了,大量摘抄原文】

    目录

    第一章 Java程序设计概述

    1.1 java程序设计平台

    1.2 java"白皮书"的关键术语

    1.3 java applet 与 Internet

    1.4 java的发展史

    1.5 关于java的常见误解


    第一章 Java程序设计概述

    1.1 java程序设计平台

    1.2 java"白皮书"的关键术语

    1. 简单性

      人们希望构建一个无需深奥的专业训练就可以进行编程的系统,并且要符合标准惯例。

      在设计java的时候尽可能接近C++是为了系统能够更易于理解。

      Java剔除了C++中许多很少使用、难以理解、易混淆的特性。

       

    2. 面向对象
    3. 分布性
      1. java有一个丰富的例程库,用于处理像HTTP和FTP之类的TCP/IP协议。java应用程序能够通过URL打开和访问网络上的对象,其便捷成都就好像访问本地文件一样。
    4. 健壮性
      1. ​​​​​​​Java采用的指针模型可以消除重写内存和损坏数据的可能性。
      2. java编译器能够检测许多在其他语言中仅在运行时才能检测出来的问题。
    5. 安全性
      • ​​​​​​​​​​​​​​​​​​​​​
    6. 体系结构中立
      • ​​​​​​​体系结构中立 --- Java编译器通过生成与特定的计算机体系结构无关的字节码指令来实现这一特性。
      • 编译器生成一个体系结构中立的目标文件格式,这是一种编译过的代码,只要有java运行时的系统,这些编译后的代码可以在许多处理器上运行。
      • 精心设计是字节码不仅可以很容易地在任何机器上解释执行,而且还可以动态地翻译成本地机器代码。
      • java虚拟机:
        • 解释虚拟机指令肯定会比全速运行机器指令慢很多,然而虚拟机有一个选项,可以将执行最频繁的字节码序列翻译成机器码,这一过程被称为即时编译。
        • java虚拟机还有一些其他的优点、它可以检测指令序列的行为,从而增强其安全性。
    7. 可移植性
      • ​​​​​​​在java中数据类型具有固定的大小,这消除了代码移植时令人头疼的主要问题。
      • 二进制数据以固定的格式进行存储和传输,消除了字节顺序的困扰。字符串是用标准的Unicode格式存储 的。
      • 作为系统组成部分的类库,定义看可移植的接口。例如,有一个抽象的window类,并给出了在Unix、Windows和Machtosh环境下的不同实现。
      • 除了与用户界面有关的部分外,所有其他的java库都能很好地支持平台独立性。你可以处理文件、正则表达式、XML、日期和时间、数据库、网络连接、线程等,而不用担心底层操作系统。
      • 不仅程序是可移植的,Java API往往也比原生API质量更高。
    8. 解释型
      • ​​​​​​​Java解释器可以在任何移植了解释器的机器上执行Java字节码。由于链接是一个增量式且轻量级的过程,所以开发过程变得更加快捷,更加具有探索性。
    9. 高性能
      • ​​​​​​​字节码可以(在运行时刻)动态地翻译成对应运行这个应用的特定的CPU的机器码。
      • 现在即时编译器已经非常出色,以至于成为了传统编译器的竞争对手。在某些情况下,甚至超越了传统编译器,原因是他们含有更多可用的信息。例如,即时编译器可以监控经常执行哪些代码,并优化这些代码以提高速度。更为复杂的优化是消除函数调用(即“内联”)。即时编译器知道哪些类已经加载。基于当前加载的类集,如果特定的函数不会被覆盖,就可以使用内联。必要时撤销优化。
    10. 多线程
      • ​​​​​​​多线程可以带来更好的交互响应和实时行为。
      • java是第一和支持并发程序设计的主流语言。
    11. 动态性
      • java与C/C++比更加具有动态性。它能够适应不断发展的环境。库中可以自由地添加新方法和实例变量,而对客户端却没有任何的影响。在java中找出运行时类型信息十分简单

    第一章提到的 java与C++ 的区别

    1.    java没有头文件、指针运算(甚至指针语法)、结构、联合、操作符重载、虚基类
    2. C++可以实现多重继承而java的类不能多重继承,但是java的类可以同时实现多个接口。
    3. 与C++相比,java提供了更丰富的运行时的自省功能。
    4. Java采用的指针模型可以消除重写内存和损坏数据的可能性。
    5. Java中的int永远为32位的整数。在C/C++中,int可能是16位整数、32位整数,也可能是编译器提供商制定的其他大小。唯一的限制只是int类型的大小不能低于short int 并且不能高于long int。
    6. java与C/C++比更加具有动态性。它能够适应不断发展的环境。库中可以自由地添加新方法和实例变量,而对客户端却没有任何的影响。在java中找出运行时类型信息十分简单。

    1.3 java applet 与 Internet

    用户从Internet下载java字节码,并在自己是机器上运行。在网页上运行的java程序称为applet。要使用applet,需要启用java的web浏览器执行字节码。不需要安装任何软件。任何时候只要访问包含applet的网页都会得到程序的最新版本。最重要的是,要感谢虚拟机的安全性,它让我们不必再担心来自恶意代码的攻击。

    1.4 java的发展史

    1.5 关于java的常见误解

    1.java是HTML的扩展?

        java是一种程序设计语言;HTML是一种描述网页结构的方式。除了用在网页上放置java applet的HTML扩展之外,两者没有任何共同之处。

    2. 使用XML,所以不需要Java?

      java是一种程序设计语言;XML是一种描述数据的方式。可以使用任何一种程序设计语言处理XML数据,而java API对XML处理提供了很好的支持。此外,许多重要的第三方XML工具采用java编写。

    3. java是一种非常容易学习的程序设计语言?

    4. java将成为适用于所有平台的通用性编程语言?

       从理论上讲,这是完全可以实现的。但实际上,某些领域其他语言有更出色的表现,

    5. java只不过是另外一种程序设计语言?

    java是一种很好的程序设计语言,很多程序设计人员喜欢java 胜过C、C++或C#。有上百种好的程序设计语言没有广泛地流行,而带有明显缺点的语言,如:C++、Visual Basic却大行其道。

    这是为什么呢?程序设计语言的成功更多取决于其支撑系统的能力,而不是优美的语法。人们主要关注:1)是否提供了易于实现某些功能的易用、便捷和标准的库?2)是否有开发工具提供商能建立强大的编程和调试环境?3)语言和工具集是否能够与其他计算基础架构整合在一起?

    java的成功源于其类库能够让人们轻松地完成原本有一定难度的事情。例如:联网高。但这些并不是java成功的全部原因。

    展开全文
  • 读书笔记--Java语言程序设计

    千次阅读 2018-11-15 20:27:20
    为了能够进行通用程序设计,一个好的经验是把变量定义为父类型,这样,它就可以接受任何子类型的值。 instanceof是Java的关键字。在Java关键字中的每个字母都是小写的。 为了更好地理解类型转换,可以认为它们...

    第11章 继承和多态

    11.1 引言

    面向对象的编程允许你从已经存在的类中定义新的类,这称为继承。

    11.2 父类和子类

    继承使得你可以定义一个通用的类(即父类),之后扩充该类为一个更加特定的类(即子类)。

    使用类来对同一类型的对象建模。不同的类也可能会有一些共同的特质和行为,这些共同的特质和行为都统一放在一个类中,它是可以被其他类所共享的。你可以定义特定的类继承通用类中的特征和方法。

    在Java术语中,如果类C1扩展自另一个类C2,那么就称C1为次类(subclass),将C2称为超类(superclass)。超类也称为父类(parent class)或基类(base class),次类又称为子类(child class),扩展类(extended class)或派生类(derived class)。子类从它的父类中继承可访问的数据域和方法,还可以添加新数据域和方法。

    和传统的理解不同,子类并不是父类的一个子类,实际上,一个子类通常比它的父类包含更多的信息和方法。

    父类的私有数据域在该类之外是不可访问的,因此,不能在子类中直接使用,但是,如果父类中定义了公共的访问器/修改器,那么可以通过这些公共的访问器/修改器来访问和修改它们。

    不是所有的“是一种”(is-a)关系都该用继承来建模。

    继承是用来为“是一种”(is-a)建模的。不要仅仅为了重用方法这个原因而盲目地扩展一个类。一个父类和它的子类之间必须存在是“是一种”(is-a)关系。

    某些程序设计语言是允许从几个类派生出一个子类的。这种能力称为多重继承(multiple inheritance)。但是在Java中是不允许多重继承的。一个Java类只可能直接继承自一个父类。这种限制称为单一继承(single inheritance)。如果使用extends关键字来定义一个子类,它只允许有一个父类。

    11.3 使用super关键字

    关键字super指代父类,可以用于调用父类中的普通方法和构造方法。

    子类继承它的父类中所有可访问的数据域和方法。关键字super是指这个super关键字所在的类的父类。关键字super可以用于两种途径:

    1)调用父类的构造方法。

    2)调用父类的方法。

    11.3.1 调用父类的构造方法

    构造方法用于构建一个类的实例。不同于属性和普通方法,父类的构造方法不会被子类继承。它们只能使用关键字super从子类的构造方法中调用。

    调用父类构造方法的语法是:super()或者super(parameters);

    语句super()调用父类的无参构造方法,而语句super(arguments)调用与参数匹配的父类的构造方法。语句super()和super(arguments)必须出现在子类构造方法的第一行,这是显式调用父类构造方法的唯一方式。

    要调用父类构造方法就必须使用关键字super,而且这个调用必须是构造方法的第一条语句。在子类中调用父类构造方法的名字会引起一个错误。

    11.3.2 构造方法链

    构造方法可以调用重载的构造方法或父类的构造方法。如果它们都没有被显式地调用,编译器就会自动地将super()作为构造方法的第一条语句。

    在任何情况下,构造一个类的实例时,将会调用沿着继承链的所有父类的构造方法。当构造一个子类的对象时,子类构造方法会在完成自己的任务之前,首先调用它的父类的构造方法。如果继承自其他类,那么父类构造方法又会在完成自己的任务之前,调用它自己的父类的构造方法。这个过程持续到沿着这个继承体系结构的最后一个构造方法被调用为止。这就是构造方法链(constructor chaining)。

    一般情况下,最好能为每个类提供一个无参构造方法,以便于对该类进行扩展,同时避免错误。

    11.3.3 调用父类的方法

    关键字super不仅可以引用父类的构造方法,也可以引用父类的方法。所用语法如下:

    super.方法名(参数)

    11.4 方法重写

    要重写一个方法,需要在子类中使用和父类一样的签名以及一样的返回值类型来对该方法进行定义。

    子类从父类中继承方法。有时,子类需要修改父类中定义的方法的实现,这称作方法重写(method overriding)。

    仅当实例方法是可访问时,它才能被覆盖。因为私有方法在它的类本身以外是不可访问的,所以它不能被覆盖。如果子类中定义的方法在父类中是私有的,那么这两个方法完全没有关系。

    与实例方法一样,静态方法也能被继承。但是,静态方法不能被覆盖。如果父类中定义的静态方法在子类中被重新定义,那么在父类中定义的静态方法将被隐藏。可以使用语法:父类名.静态方法名(Superclass.staticMethodName)调用隐藏的静态方法。

    11.5 方法重写与重载

    重载意味着使用同样的名字都是不同的签名来定义多个方法。重写意味着在子类中提供一个都方法的新的实现。

    方法重写是指该方法必须使用相同的签名和相同的返回值类型在子类中定义。

    方法重写发生在通过继承而相关的不同类中;方法重载可以发生在同一类中,也可以发生在由于继承而相关的不同类中。

    方法重写具有同样的签名和返回值类型;方法重载具有同样的名字,都是不同的参数列表。

    为了避免错误,可以使用一个特殊的Java语法,称为重写标注(override annotation),在子类的方法前面发一个@override。

    该标注表示被标注的地方必须重写父类的一个方法。如果具有该标注的方法没有重写父类的方法,编译器将报告一个错误。如果没有使用重写标注,编译器不会报告错误。使用标注可以避免错误。、

    11.6 Object类及其toString()方法

    Java中的所有类都继承自java.lang.object类。

    如果在定义一个类时没有指定继承性,那么这个类的父类就被默认是Object。

    toString()方法的签名是:public String toString()

    调用一个对象的toString()会返回一个描述该对象的字符串。默认情况下,它返回一个由该对象所属的类名、at符号(@)以及该对象的描述性字符串。应该重写toString方法,这样,它可以返回一个代表该对象的描述性字符串。

    也可以传递一个对象来调用System.out.println(object)或者System,out.print(object)。这等价于调用System.out.println(object.toString())或者System.out.print(object.toString())。

    11.7 多态

    多态意味着父类的变量可以指向子类对象。

    首先,定义两个有用的术语:子类型和父类型。一个类实际上定义了一个类型。子类定义的类型称为子类型(suntype),而父类定义的类型称为父类型(supertype)。

    继承关系使一个子类继承父类的特征,并且附加一些新特征。子类是它的父类的特殊化,每个子类的实例都是其父类的实例,但是反过来就不成立。例如:每个圆都是一个几何对象,但并非每个几何对象都是圆。因此,总可以将子类的实例传给需要父类型的参数。

    使用父类对象的地方都可以使用子类的对象。这就是通常所说的多态(polymorphism,它源于希腊文字,意思是“多种形式”)。简单来说,多态意味着父类型的变量可以引用子类型的对象。

    11.8 动态绑定

    方法可以在沿着继承链的多个类中实现,JVM决定运行时调用哪个方法。

    方法可以在父类中定义而在子类中重写。例如,toString()方法是在Object类中定义的,而在GeometricObject类中重写。思考下面的代码:

    Object o = new GeometricObject();
    
    System.out.println(o.toString()); 

    这里的o调用哪个toString()呢?为了这个问题,我们首先介绍两个术语:声明类型和实际类型。一个变量必须被声明为某种类型,变量的这个类型称为它的声明类型(declared)。这里,o的声明类型是object。一个引用类型变量可以是一个null值或者是对一个声明类型实例的引用。实例可以使用声明类型或者它的子类型的构造方法创建。变量的实际类型(actual typr)是被变量引用的对象的实际类。这里,o的实际类型是GeometricObject,因为o指向使用new GeometricObject()创建的对象。o调用哪个toString()方法由o的实际类型决定,这称为动态绑定。

    动态绑定机制如下:假设对象o是类C1,C2,...,Cn-1,Cn的实例,其中C1是C2的子类,C2是C3的子类。也就是说,Cn是最通用的类,C1是最特殊的类。在Java中,Cn是Object类。如果对象o调用一个方法p,那么JVM会一词在类C1,C2,...,Cn-1,Cn中查找方法p的实现,知道找到为止。一旦找到一个实现,就停止查找,任何调用这个首先找到的实现。

    匹配方法的签名和绑定方法的实现是两个不同的问题。引用变量的声明类型决定了编译时匹配哪个方法。在编译时,编译器会根据参数类型、参数个数和参数顺序找到匹配的方法。一个方法可能在沿着继承链的多个类中实现。Java虚拟机在运行时动态绑定方法的实现,这是由变量的实际类型决定的。

    11.9 对象转换和instanceof运算符

    对象的引用可以类型转换为对另外一种对象的引用,这称为对象转换。

    总是可以将一个子类的实例转换为一个父类的变量,称为向上转换(upcasting),因为子类的实例永远是它的父类的实例。当把一个父类的实例转换为它的子类变量(称为向下转换(downcasting))时,必须使用转换记号“(子类名)”进行显式转换,向编译器表明你的意图,为使转换成功,必须确保要转换的对象是子类的一个实例。如果父类对象不是子类的一个实例,就会出现一个运行异常ClassCastException。例如:如果一个对象不是Student的实例,它就不能转换成Student类型的变量。因此,一个好的经验是,在尝试转换之前确保该对象是另一个对象的实例。这是可以利用运算符instanceof来实现的。

    为了能够进行通用程序设计,一个好的经验是把变量定义为父类型,这样,它就可以接受任何子类型的值。

    instanceof是Java的关键字。在Java关键字中的每个字母都是小写的。

    为了更好地理解类型转换,可以认为它们类似与水果、苹果、橘子之间的关系,其中水果类Fruit是苹果类Apple和橘子类Orange的父类。苹果是水果,所以,总是可以将Apple的实例安全地赋值给Fruit变量。但是,水果不一定是苹果,所以,必须进行显示转换才能将Fruit的实例赋值给Apple的变量。

    只有源对象是目标类的实例时才能进行类型转换。在执行转换钱,程序使用instanceof运算符来确保源对象是否是目标类的实例。

    对象成员访问运算符(.)优先于类型转换运算符。使用圆括号保证在点运算(.)之前进行转换。对基本类型值进行转换不同于对对象进行转换。转换基本类型值返回一个新的值。而转换对象引用不会创建一个新的对象。

    11.10 Object类的equals方法

    如同toString()方法,equals(Object)方法是定义在Object类中的另外一个有用的方法。

    在Object类中定义的另外一个经常使用的方法是equals方法。它的签名是:

    public boolean equals(Object o)

    这个方法测试两个对象是否相等。调用它的语法是:

    object1.equals(object2);

    Object类中equals方法的默认实现是:

    public boolean equals(Object obj) {
    
        return (this == obj);
    
    }

    这个实现使用==运算符检测两个引用变量是否指向同一个对象。因此,应该在自己的客户类中重写这个方法,以测试两个不同的对象是否具有相同的内容。

    equals方法在Java API的许多类中被重写,比如Java.lang.String和Java.util.Date,用于比较两个对象的内容是否相等。String类中equals方法继承自Object类,然后在String类中被重写,使之能够检验两个字符串的内容是否相等。

    比较运算符==用来比较两个基本数据类型的值是否相等,或者判断两个对象是否具有相同的引用。如果想让equals方法能够判断两个对象是否具有相同的内容,可以在定义这些对象的类时,重写类中的equals方法。运算符==要比equals方法的功能强大些,因为==运算符可以检测两个引用变量是否指向同一个对象。

    在子类中,使用签名eqauls(SomeClassName obj) (例如:equals(Circle obj))重写equals方法是一个常见错误,应该使用equals(Object obj)。

    11.11 ArrayList类

    ArrayList对象可以用于存储一个对象列表。

    ArrayList是一种泛型类,具有一个泛型类型E。创建一个ArrayList时,可以指定一个具体的类型来替换E。例如,下面语句创建一个ArrayList,并且将其引用赋值给变量cities。该ArrayList对象可以用于存储字符。

    ArrayList<String> cities = new ArrayList<String>();

     

    从JDK1.7开始,语句

    ArrayList<AConcreteType> list = new ArrayList<AconcreteType>();

    可以简化为

    ArrayList<AconcreteType> list = new ArrayList<>();

    由于使用了称为类型推导的特征,构造方法中不再要求给出具体类型。编译器可以从变量的声明中推到出类型。

    操作数组ArrayList
    创建数组/数组列表String[] a = new String [10]ArrayList list< String > = new ArrayList()
    引用元素a[index]

    liset.get(index)

    更新元素a[index] = "London";list.set(index, "London");
    返回大小a.lengthlist.size()
    添加一个新元素 list.add("London")
    插入一个新元素 list.add(index, "London")
    删除一个元素 list.remove(index)
    删除一个元素 list.remove(Object)
    删除所有元素 list.clear()

     

     

     

     

     

     

     

     

     

     

    一旦创建了一个数组,它的大小就确定下来了。可以使用方括号访问数组元素(例如:a[index])。当创建ArrayList后,它的大小为0,如果元素不在数组列表中,就不能使用get(index)和set(index.element)方法。向数组列表中添加、插入和删除元素是比较容易的,而向数组中添加、插入和删除元素是比较复杂的。为了实现这些操作,必须编写代码操纵这个数组。注意,可以使用java.util.Arrays.sort(array)方法来对一个数组排序。如果要对一个数组列表排序。使用java.util.Collections.sort(arrayList)方法。

    使用ArrayList来实现某些程序更简单,有以下两个原因:

           ArrayList的大小是灵活的,所以无须提前给定它的大小。而当创建一个数组时,它的大小必须给定。

           ArrayList包含许多有用的方法。比如,可以使用contains方法来测试某个元素是否在列表中。如果使用数组,则需要                    编写额外代码来实现该方法。

    可以在数组里使用foreach循环来遍历元素。数组列表中的元素也可以使用foreach循环来进行遍历,语法如下:

    for (elementType element: arrayList) {
    
        // Process the element
    
    }

    11.14 protected数据和方法

    私有变量只能在类里访问,而公共成员可以被任意的其他类访问。

    经常需要允许子类访问定义在父类中的数据域或方法,但不允许非子类访问这些数据域和方法。可以使用protected完成该功能。父类中被保护的数据域或方法可以在它的子类中访问。

    修饰符private、protected和public都称为可见性修饰符(visibility modifier)或可访问性修饰符(accessibility modifier),因为它们指定如何访问类和类的成员。这些修饰符的可见性按下面的顺序递增:

     

    表总结了类中成员的可访问性。

    数据和方法的可见性
    类中成员的修饰符在同一类可访问在同一包内可访问在子类内可访问在不同包可访问
    public    
    protected   ---------------------
    (default)  ------------------------------------------
    private ------------------------------------------------------------------

     

     

     

     

     

     

    使用private修饰符可以完全隐藏类的成员,这样,就不能从类外直接访问它们,不使用修饰符就表示允许同一个包里的如何类直接访问类的成员,但是其他包中的类不可以访问。使用protected修饰符允许任何包中的子类或同一包中的类访问类的成员。使用public修饰符允许任意类访问类的成员。

    类可以以两种方式使用:一种是用于创建该类的实例;另一种是通过扩展该类创建它的子类。如果不想从类的外部使用类的成员,就把成员声明成private。如果想让该类的用户都能使用类的成员,就把成员声明成public。如果想让该类的扩展者使用数据和方法,而不想让该类的用户使用,则把成员声明成protected。

    修饰符private和protected只能用于类的成员。public修饰符和默认修饰符(也就是没有修饰符)既可以用于类的成员,也可以用于类。一个没有修饰符的类(即非公共类)是不能被其他包中的类访问的。

    子类可以重写它的父类的protected方法,并把它的可见性改为public。但是,子类不能削弱父类中定义的方法的可访问性。例如:如果一个方法在父类中定义为public,在子类中也必须定义为public。

    11.15 防止扩展和重写

    一个被final修饰的类和方法都不能被扩展。被final修饰的数据域是一个常数。

    有时候,可能希望防止类扩展。在这种情况下,使用final修饰符表明一个类是最终的,是不能作为父类的。Math就是一个最终类。String、StringBuilder和StringBuffer类也可以是最终类。也可以定义一个方法为最终的,最终方法不能被它的子类重写。

    修饰符public、protected、private、static、abstract以及final可以用在类和类的成员(数据和方法)上,只有final修饰符还可以用在方法中的局部变量上。方法内的最终局部变量就是常量。

    展开全文
  • 1. 计算机中字节(byte)是最小的存储单位,1 byte = 8bit 2.内存 随机访问存储器 (RAM) 3. 代码风格 4. 从控制台读取输入/键盘输入 Scanner scanner = new Scanner(System.in);......

    1. 计算机中字节(byte)是最小的存储单位,1 byte = 8bit

    2.内存  随机访问存储器 (RAM)

    3. 代码风格

     

    4. 从控制台读取输入/键盘输入

    Scanner scanner = new Scanner(System.in);
    Double x;
    x = scanner.nextDouble();

    5. 命名习惯

     

     6. 命名常量

    final Double pi = 3.1415926;

    7.数值类型  / String

    前4种为整数,后两种为浮点型

     

    8. 数值操作符/幂运算    整数除法  浮点数除法

    幂运算:a^b

    Math.pow(a,b);

    9. 产生随机数

     

    10.指定输出宽度和精度

    11.基本类型变量和引用类型变量的区别

    基本类型

    而此时不论更改C1还是C2的值,效果是一样的,更改的是指定内存中的值,此时打印C1和C2中的值都会被改变

    12 静态变量、常量、方法

     13. 可见性修饰符

    14.数据域封装

    15.不可变类

     16.变量的作用域

    一个类的实例变量和静态变量称为类变量数据域,无论在何处申明,类变量的作用范围都是整个类。

    局部变量:类内的变量

    17 方法的重写、重载

    重载时方法名一样,参数不一样

    18 多态 

    使用父类对象的地方都可以使用子类的对象,这就是通常说的多态。

     

    声明类型: 一个变量必须被声明为某种类型,变量的这个类型称为它的声明类型,上图中 o的声明类型是Object

                   一个引用类型变量可以是null值或是一个队声明类型实例的引用。

                   实例可以使用声明类型或它的子类型的构造方法创建。

    实际类型:被变量引用的对象的实际类。

    19 对象转换、instance of

    对基本类型进行转换不同于对对象进行转换,转换基本类型值返回一个新的值。而转换一个对象引用不会创建一个新的对象

    20 equals方法

    21 final  防止扩展和重写 

    22 异常处理

    异常是从异常类创建的对象;

     

    23 File类

     

     File对象封装了文件或路径的属性,但是它既不包括创建文件的方法,也不包括从/向文件读/写数据(称为数据输入输出,简称I/O)的方法。

     

    24 泛型

     

    展开全文
  • 内容源自清华大学出版的《Java程序设计习题集》,小弟将自己做题的笔记整理了一部分,与各位分享,请勿用于商业目的!谢谢
  • 采用java技术构建的一个管理系统。整个开发过程首先对系统进行需求分析,得出系统的主要功能。接着对系统进行总体设计和详细设计。总体设计主要包括系统功能设计、系统总体结构设计、系统数据结构设计和系统安全设计...
  • 第一章1.6库ApplicationProgramInterface (API)应用程序接口JDK:JAVADevelopment Toolkit用于开发测试的程序IDE:Intergrated Development Environment IDE集成开发环境1.7public class Welcom{ }类块public static...
  • Java编程思想读书笔记(一)

    千次阅读 2016-01-04 18:05:39
    第1章 对象导论 1. 将类的一个对象置于某个新的类中,称为“创建一个成员对象”。 2. 使用现有的类合成新的类,称为“组合”(composition),如果组合是动态发生的,通常被称为“聚合”...4. 在Java中,所有的类最
  • l ECMAScript,有ECMA-262定义,明确javascript这门语言的规则和约定,好比为开始一场游戏指定的游戏规则、规范、约定。 l DOM:提供访问和操作网页内容的方法和接口 l BOM,提供与浏览器交互的方法和接口 ECMA-262规定...
  • Java编程思想读书笔记(一)第1~13、16章

    万次阅读 多人点赞 2017-11-26 18:54:06
    目录: Java编程思想(一)第1~13、16章 ...Java编程思想(五)第18章-Java IO系统 Java编程思想(六)第19章-枚举类型 Java编程思想(七)第20章-注解 Java编程思想(八)第21章-并发 第1章 对象导论 1.1
  • 前8章左右是看第八版做的笔记,后面是看第十版做的笔记,影响不大,可以正常参考,笔记多为记录书中重要内容和自己的心得,附录也有很多扩展和总结的相关知识,如内存相关知识、static关键字等等,希望对你有所帮助...
  • Java Web读书笔记

    2020-09-20 20:23:08
    《深入分析Java Web技术内幕》读书笔记 第1章 - 深入Web请求过程 互联网网络架构类型: C/S架构:Client / Server。采用长连接交互模式 B/S架构:Browser / Server。优势在于浏览器具有统一性/简单。服务端基于...
  • Java编程思想》读书笔记读《Java编程思想》的一些心得1、一切皆对象到底存在了什么地方2、操作符3、初始化与清理4、复用类5、接口 读《Java编程思想》的一些心得 ​ 《Java编程思想》,也叫《Thinking in Java》...
  • Thinking in Java读书笔记

    万次阅读 多人点赞 2019-07-31 18:37:16
    Thinking in Java读书笔记(IO和并发除外) 1.1、类中所有的private方法都隐式地指定为final的,由于其他类无法取用private方法,所以也就无法覆盖它;private方法无法被重写,继承对应private的方法无效,private...
  • 七:对象和类 <br /> 可见性修饰符: public 使类,方法,数据域可以在任何类中访问 private使方法,数据域只能从自身所在的类中访问 不用以上两者的默认情况下,可以从同一个包的...
  • JAVA核心技术读书笔记 第三章 JAVA的基本程序设计结构 数据类型、常量、运算符、数学函数、数值类型转换、关系和boolean运算符、位运算符、字符串、输入、循环、大数值、数组拷贝、数组排序、多维数组
  • 由于没把编程思想带回来,于是买了本Java核心技术看看,刚开始看确实有不少收获,虽然说做过项目,但是对于一些基础只是或者细节还是不知道的,借此假期也好好研究一下。1.Java语言的发展状况 首先看看Java的发展 ...
  • 博文链接:https://p48376382.iteye.com/blog/120701
  • Java.编程思维---图灵程序设计丛书》读书笔记
  • 第一章:Java程序设计概述 概述Java与其它程序设计语言不同性能 设计初衷 哪方面达到预期效果 简述Java诞生和发展历史 1.Java程序设计平台 Java是一个完整的平台,有一个庞大的库,其中包含很多可重用的代码和一...
  • Java面向对象程序设计笔记 提示:写完文章后,目录可以自动生成,如何生成可参考右边的帮助文档 文章Java面向对象程序设计笔记一、Java的特点1.1简单性二、Java的加载与执行1.引入库2.读 提示:以下是本篇文章...
  • 实战Java高并发程序设计-读书笔记

    千次阅读 2018-05-31 19:35:44
    实战Java高并发程序设计-读书笔记 第一章 死锁、饥饿、活锁的概念。 并发级别:阻塞、饥饿、无障碍、无锁、无等待。 无障碍:是一种最弱的非阻塞调度。两个线程如果是无障碍的执行,那么他们不会因为临界区的...
  • Java高并发程序设计读书笔记一 第一章 走入并行世界 1、基本概念 同步:同步方法一旦开始,调用者必须等到方法调用返回后,才能继续后续操作 异步:一旦开始,方法调用就会立即返回,...
  • 本篇内容为读马月坤、赵全明两位老师编著清华大学出版社出版的《Java Web 程序设计与开发》的读书笔记。之前读了一天的人民邮电出版社的《JSP程序设计慕课版》,可能是我没有结合视频的缘故,感觉效果不好,因而换了...
  • 笔记汇总了作者认为“JavaScript高级程序设计”这本书的前七章知识重点,仅供参考。 第七章 函数表达式 小结: 在JavaScript编程中,函数表达式是一种非常有用的技术。使用函数表达式可以无须对函数命名,...
  • 《深入理解java虚拟机》读书笔记1-类文件结构 最近在看周志明老师写的《深入理解java虚拟机》,学到了很多,也有很多没理解的地方,觉得需要做读书笔记。 无关性基石 java虚拟机不与包括java语言在内的任何程序语言...
  • 模块加载,其实就是把js分成很多个模块,便于开发和维护。因此加载很多js模块的时候,需要动态的加载,以便提高用户体验。 在介绍模块加载库之前,先介绍一个方法。 动态加载js方法: 代码如下: ...
  • 走进并行世界1.2 java并行程序基础1.3 jdk并发包1.4 锁的优化以及注意事项1.5 并行模式与算法1.6 java 8 9 10与并发1.7 使用akka构建高并发程序1.8 并行程序调试1.9 jetty核心代码分析 1.概述 看完这本书 看看...
  • 采用java技术构建的一个管理系统。整个开发过程首先对系统进行需求分析,得出系统的主要功能。接着对系统进行总体设计和详细设计。总体设计主要包括系统功能设计、系统总体结构设计、系统数据结构设计和系统安全设计...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,551
精华内容 4,220
关键字:

java程序设计读书笔记

java 订阅