1. 类及类的成员
1.1 类
(1)默认初始化；
(2)属性显式初始化；
(3)构造器中初始化；
(4)通过“对象.属性“或“对象.方法”的方式赋值
(5)在代码块中赋值
属性赋值先后顺序：(1)—>(2)/(5)—>(3)—>(4)
1.3 方法
Java里的方法不能独立存在，所有的方法必须定义在类里。
- 方法中只能调用方法或属性，不可以在方法中定义方法
- 声明方法：修饰符 返回值类型 方法名(参数类型形参1, 参数类型形参2, …){方法体程序代码; return 返回值; }
- 如果方法有返回值、则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用return关键字来返回指定类型的变量或常量。
- 如果方法没有返回值，则方法声明时，返回值类型用关键字void表示，方法体中可以不必使用return语句。如果使用return语句，仅用来结束方法。
- 方法的重载（overload）：
- 在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
- 两同一不同：同一个类、相同方法名。参数列表不同：参数个数不同、参数类型不同
- 方法的重载与方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系，判断重载的标准就是两同一不同。
- 调用时，根据方法的参数列表的不同来区别。方法名 ——> 参数列表
- 示例：void show(int a,char b,double c){} 和void show(int a,double c,char b){}
- 可变形参的方法：
- 方法名(参数的数据类型 … 参数名)
- 可变个数形参：数据类型 … 形参变量名，相当于数组（JDK 5.0以前使用数组形参来定义方法，传入多个同一类型变量：数据类型[] 变量名）
- 可变参数方法的使用与方法参数部分使用数组是一致的
- 当调用可变个数形参的方法时，传入的参数个数可以是：0个、1个、2个….
- 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载。
- 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。二者不能共存。
- 可变个数形参在方法的形参中，必须声明在末尾。
- 可变个数形参在方法的形参中，最多只能声明一个可变形参。
- 方法参数的值传递机制：
- 形参：方法声明时( )内的参数；实参：方法调用时实际传给形参的参数值
- 形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参
- 形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参
- 特殊情况：String是的数据值传递。String的不可变性
递归方法：
格式：修饰符 类名(参数列表) { 初始化语句；}
- 构造器的作用：
- 创建对象；
- 给对象进行初始化（初始化对象的属性）
- 根据参数不同，构造器可以分为两类：
- 隐式无参构造器（系统默认提供）；
- 显式定义一个或多个构造器（无参、有参）
- 不能声明返回值类型；不能被static、final、synchronized、abstract、native修饰；不能有return语句。
- 一个类都至少有一个构造器。如果没有显式的定义类的构造器，系统会默认提供一个空参构造器，其权限修饰符与所属类的权限修饰符一致。一旦显式定义了构造器，系统就不会再提供默认空参构造器。
- 一个类中可以定义多个重载的构造器。构造器重载使得对象的创建更加灵活，方便创建各种初始化值不同的对象。构造器重载，参数列表必须不同。
-
1.5 代码块
代码块的作用：用来初始化类、对象，又称为初始化块。
- 代码块如果有修饰的话，只能使用static
- 分类：
- 静态代码块
- 内部可以有输出语句
- 随着类的加载而执行，而且只执行一次
- 作用：初始化类的信息
- 如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
- 静态代码块的执行要优先于非静态代码块的执行。
- 静态代码块内只能调用静态的属性和静态的方法，不能调用非静态的结构
- 非静态代码块
- 静态代码块
- 内部可以有输出语句。
- 随着对象的创建而执行。
- 每创建一个对象，就执行一次非静态代码块。
- 作用：可以在创建对象时，对对象的属性进行初始化。
- 如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
- 非静态代码块内可以调用静态的属性、静态的方法、或非静态的属性 、非静态的方法。
- 创建对象的时候非静态代码优先于构造器执行
- 对象可以赋值的位置
(1)默认初始化
(2)显示初始化
(3)构造器初始化
(4)有了对象以后、可以通过“对象.属性”或“对象.方法”的方式，进行赋值。
(5)在代码块中赋值
- 赋值的顺序：(1)—>(2)/(5)—>(3)—>(4)
实例化子类对象时，涉及父类、子类中静态代码块、非静态代码块、构造器的加载顺序：由父及子，静态先行。通俗来说就是父类静态代码块—>子类静态代码块—>父类非静态代码块—>父类构造器—->子类非静态代码块—->子类构造器。
1.6 内部类
Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类。
- 内部类的分类：成员内部类(静态、非静态) VS 局部内部类(方法内、代码块内、构造器内)
- 成员内部类：
- 一方面：作为外部类的成员
- 调用外部类的结构
- 可以被static修饰，但此时就不能再使用外层类的非static的成员变量
- 可以被4种不同的权限修饰（与之前的不同）， 和外部类不同，Inner class还可以声明为private或protected；
- 另一方面，作为一个类：
- 类内可以定义属性、方法、构造器等。
- 可以被final修饰，表示此类不能被继承。言外之意，不使用final，就可以被继承。
- 可以被abstract修饰
- 一方面：作为外部类的成员
- 局部内部类
- 局部内部类使用的一个注意点：在局部内部类的方法中（比如：show）如果调用局部内部类所声明的方法（比如：method）中的局部变量（比如num），要求此局部变量声明为final的。jdk7及之前版本要显示的声明final，jdk8及之后的版本可以不用显示的声明final。
- 关注如下3个问题
- 如何实例化成员内部类的对象
- 如何在成员内部类中区分调用外部类的结构
- 开发中局部内部类的使用 ```java public class InnerClassTest { public static void main(String[] args) { //创建Dog实例(静态的成员内部类): Person.Dog dog = new Person.Dog(); dog.show(); //创建Bird实例(非静态的成员内部类): //Person.Bird bird = new Person.Bird();//错误的 Person p = new Person(); Person.Bird bird = p.new Bird(); bird.sing(); System.out.println(); bird.display(“黄鹂”); } }
class Person{ String name = “小明”; int age; public void eat(){ System.out.println(“人：吃饭”); } //静态成员内部类 static class Dog{ String name; int age; public void show(){ System.out.println(“卡拉是条狗”); //eat(); } } //非静态成员内部类 class Bird{ String name = “杜鹃”; public Bird(){
}public void sing(){System.out.println("我是一只小小鸟");Person.this.eat();//调用外部类的非静态属性eat();System.out.println(age);}public void display(String name){System.out.println(name);//方法的形参System.out.println(this.name);//内部类的属性System.out.println(Person.this.name);//外部类的属性}}public void method(){//局部内部类class AA{}}{//局部内部类class BB{}}public Person(){//局部内部类class CC{}}
}
<a name="iCKa9"></a># 2. 类和对象- 类是对一类事物的描述；对象是实际存在的该类事物的一个个体，也称为实例。- 对象的创建和使用（类的实例化或创建类的对象）：- 创建对象：类名对象名= new 类名();- 访问对象成员（包括属性和方法）：对象名.对象成员- 类的访问机制- 在一个类中的访问机制：类中的方法可以直接访问类中的成员变量。例外：static方法不能访问非static- 在不同类中的访问机制：先创建要访问类的对象，再用对象访问类中定义的成员。例外：static方法- jvm中的栈、堆、方法区、静态域的概念- 堆（Heap），此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。这一点在Java虚拟机规范中的描述是：所有的对象实例以及数组都要在堆上分配。- new出来的数组、对象在堆中，new几个堆空间就有几个对象。- 设计类时声明（和初始化或默认初始化）的属性不同于局部变量，存在于堆空间中。- 栈（Stack），是指虚拟机栈。虚拟机栈用于存储局部变量等。局部变量表存放了编译期可知长度的各种基本数据类型（boolean、byte、char、short、int、float、long、double）、对象引用（reference类型，它不等同于对象本身，是对象在堆内存的首地址）。方法执行完，自动释放。- 方法区（Method Area），用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。- 静态域- 对象的内存解析- 编译完源程序以后，生成一个或多个字节码文件。我们使用JVM中的类加载器和解释器对生成的字节码文件进行解释运算。意味着需要将字节码文件对应的类加载到内存中，涉及到内存解析。- 匿名对象：- 如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象。- 我们经常将匿名对象作为实参传递给一个方法调用。- JavaBean：- 类是公共的、有一个无参的公共的构造器、有属性且一般定义为private且有对应的get、set方法的Java类<a name="SosHJ"></a># 3. 三大特性<a name="wtMtl"></a>## 3.1 封装性- 问题的引入- 当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到属性的数据类型和存储范围的制约。除此之外，没有其他制约条件。但是，在实际问题中，我们往往需要给属性赋值加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。（比如：setLegs()）同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要将属性声明为私有的(private).-->此时，针对于属性就体现了封装性。- 封装性的体现- 体现1：将类的属性声明为private私有的，同时提供该属性public公共的getXxx()和setXxx()方法。- 封装性的体现，需要权限修饰符来配合。- 权限修饰符：- 权限修饰符置于类及类的成员定义前，用来限定对象对该类成员的访问权限。- Java规定的四种权限修饰符，从小到大排列：- private：类内部- 缺省：类内部、同一个包- protected：类内部、同一个包、不同包的子类- public：类内部、同一个包、不同包的子类、同一个工程- 修饰类时只能使用缺省和public。- 四种权限修饰符都可以修饰属性、方法、构造器、内部类，不可以修饰代码块。- 总结封装性：Java提供了四种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的大小。<a name="QSio8"></a>## 3.2 继承性- 继承性的好处- 减少了代码的冗余，提高了代码的复用性- 便于功能的扩展- 为之后多态性的使用，提供了前提。- 继承性的格式：class A extentds B{}- A：子类、派生类、subclass<br />B：父类、超类、基类、superclass- 体现：一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有属性和方法。**特别地**，父类声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。只是因为封装性的影响，使得子类不能直接调用父类的结构而已。- 子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的扩展。- Java关于继承性的规定- 一个类可以被多个子类继承- 类的单继承性：一个类只能有一个父类- 子父类是相对的概念- 子类直接继承的父类称为直接父类。间接继承的父类称为间接父类- 子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法- Object类- 如果我们没有显示的声明一个类的父类的话，则此类继承于java.lang.Object类- 所有的java类（除java.lang.Object类之外）都直接或间接继承于java.lang.Object类- 意味着，所有的java类具有java.lang.Object类声明的功能。- 重写(override / overwrite)- 定义：子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作。- 应用：重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。- 规定：- 子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同。- 子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符。- 父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void。- 父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类。- 父类被重写的方法的返回值类型是基本数据类型，则子类重写的方法的返回值类型必须是相同的基本数据类型。- 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型。- 子类中不能重写父类中声明为private权限的方法。虽然子类可以定义与父类中同名同参数列表的private方法，但是不认为这是重写。- 子类和父类中同名同参数的方法要么都声明为非static的（考虑重写），要么都声明为static的（不是重写）。虽然子类可以定义与父类中同名同参数列表的static方法，但是不认为这是重写。- 区分方法的重载与重写- 概念：重载是在同一个类中可以声明多个方法名相同，形参列表不同的方法，它们彼此之间构成重载。同时构造器也可以重载。重写是子类继承父类以后，可以对父类中同名同参数的方法进行覆盖操作。- 规则：重载，两同一不同。重写，看上面。- 多态性：重载不表现为多态性。重写表现为多态性。重载在编译期就确定了调用哪一个了，运行时也是这一个。重写不是，编译认为是调用父类的，运行时调用的是子类的。- 子类对象实例化的全过程- 从结果上来看：- 继承性：子类继承父类以后，就获取了父类中声明的属性或方法。创建子类的对象，在堆空间中，就会加载所有父类中声明的属性。- 从过程上来看：- 当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用其父类的构造器，进而调用父类的父类的构造器直到调用java.lang.Object类中空参的构造器为止。正因为加载过所有的父类的结构，所以在可以看到内存中有父类的结构，子类对象才可以考虑进行调用。- 明确：虽然创建子类对象时调用了父类的构造器，但是自始至终就创建过一个对象，即为new的子类对象。<a name="xiboW"></a>## 3.3 多态性- 理解多态性：- 可以理解为一个事物的多种形态- 何为多态性：- 在java中的体现：对象的多态性：父类的引用指向子类的对象（或者子类的对象赋给父类的引用）。- 编译时看左边；运行时看右边：- Java引用变量有两个类型：编译时类型和运行时类型。编译时类型由声明 该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。- 若编译时类型和运行时类型不一致，就出现了对象的多态性。- 多态情况下，看左边看的是父类的引用（父类中不具备子类特有的方法），看右边看的是子类的对象（实际运行的是子类重写父类的方法）。- 多态的使用：- 虚拟方法调用：当我们通过变量去调用子父类中同名同参数的方法时，编译的时候认为调用的是父类的方法，但是当解释运行的时候实际调用的是子类重写的方法。- 有了对象的多态性以后，我们在编译期，只能调用父类声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。- 多态性的使用前提：- 类的继承关系- 方法的重写- 适用位置：- 对象的多态性只适用于方法，不适用于属性（属性编译和运行都看左边）- 运行时行为：- 多态是运行时行为，而不是编译时行为。<a name="h8yLL"></a># 4. 关键字<a name="I1qkD"></a>## 4.1 this- this 可以调用类的属性、方法和构造器- this 调用属性和方法：- 使用this访问属性和方法时，如果在本类中未找到，会从父类中查找。- this理解为：当前对象或当前正在创建的对象。- 在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法。但是通常情况下，我们都选择省略"this."。特殊情况下，如果方法的形参和类的属性同名时，我们必须显示的使用"this.变量"的方式，表明此变量是属性，而非形参。- 在类的构造器中，我们可以使用"this.属性"或"this.方法"的方式，调用当前正在创建的对象属性或方法。但是通常情况下，我们都选择省略"this."。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显示的使用"this.变量"的方式，表明此变量是属性，而非形参。- this 调用构造器：- this可以作为一个类中构造器相互调用的特殊格式。- 在类的构造器中使用"this(形参列表)"的方式，调用本类中重载的其他的构造器。其中this(); 表示调用本类中的无参构造器- 但是构造器中不能通过"this(形参列表)"的方式调用自身构造器- 如果一个类中声明了n个构造器，则最多有 n - 1个构造器中使用了"this(形参列表)"- this(形参列表)，必须声明在类的构造器的首行- 在类的一个构造器中，最多只能声明一个"this(形参列表)"，用来调用其他的构造器。<a name="q0zrp"></a>## 4.2 super- super理解为：父类的- super可以用来调用：属性、方法、构造器- super调用属性和方法- 我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显示的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."。- 特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类声明的属性，则必须显示的使用"super.属性"的方式，表明调用的是父类中声明的属性。- 特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显示的使用"super.方法"的方式，表明调用的是父类中被重写的方法。- super调用构造器- 我们可以在子类的构造器中显示的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器- "super(形参列表)"的使用，必须声明在子类构造器的首行!- 我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)"只能二选一，不能同时出现- 当我们在构造器的首行，没有显示的声明"this(形参列表)"或"super(形参列表)"，则默认调用的是父类中空参的构造器：super()- 在类的构造器中，至少有一个类的构造器中使用了"super(形参列表)"，调用父类中的构造器- 当父类中没有空参数的构造器时，子类的构造器必须通过this(参 数列表)或者super(参数列表)语句指定调用本类或者父类中相应的 构造器。同时，只能”二选一” ，且必须放在构造器的首行- 如果子类构造器中既未显式调用父类或本类的构造器，且父类中又 没有无参的构造器，则编译出错- super和this的区别<a name="cuFAi"></a>## 4.3 static- static可以用来修饰：属性、方法、代码块、内部类。- 使用static修饰属性：静态变量（类变量）- 属性：按是否使用static修饰，又分为：静态属性 vs 非静态属性（实例变量）- 实例变量：我们创建了类的多个的对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改。- 我们创建了类的多个的对象，每个对象都共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。- static修饰属性的其他说明- 静态变量随着类的加载而加载。可以通过"类名.静态变量"的方式进行调用。- 静态变量的加载要早于对象的创建。- 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。- 调用规则：类：类变量；对象：类变量， 实例变量- 静态属性举例：System.out; Math.PI- 使用static修饰方法：静态方法- 随着类的加载而加载，可以通过"类.静态方法"的方式调用- 调用规则：类：静态方法；对象：静态方法 ， 非静态方法- 静态方法中，只能调用静态的方法和属性。非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法和属性。- static注意点：- 在静态的方法中，不能使用this关键字，super关键字。- 关于静态属性和静态方法的使用，都从生命周期的角度去理解。- static修饰的方法不能被重写- 开发中，如何确定一个属性是否要声明为static的：- 属性是可以被多个对象所共享的，不会随着对象的不同而不同。- 开发中如何确定一个方法是否声明为staticc的：- 操作静态属性的方法，通常设置为static的。工具类中的方法，习惯上声明为static的。比如，Math、Arrays、Collections- 内存解析<a name="NcCpq"></a>## 4.4 final- final：最终的- final 可以用来修饰的结构：类、方法、变量- final 用来修饰一个类：不能被其他类所继承。比如：String类、StringBuffer类、System类。- final 修饰一个方法：表明此方法不可以被重写。比如：Object类中的getClass()；- final 用来修饰变量：此时的“变量”就称为一个常量。- final 修饰属性（成员变量）：可以考虑赋值的位置有：显示初始化、代码块初始化、构造器中初始化、- final 修饰属性（成员变量）时，该属性不会被系统默认初始化赋值，必须自己进行赋值，可以显示初始化赋值、代码块初始化赋值、构造器中赋值、**最晚要在构造器执行完之前赋值完成**，因为构造器执行完成之后，类的对象就产生了，对象一出生相应的在堆空间中属性就加载了，这时候就属性就必须有值了。总结就是final标记的成员变量必须在声明时或在每个构造器中或代码块中显式赋 值，然后才能使用。- final 修饰局部变量- 尤其是使用fianl修饰形参是、声明此形参是一个常量。当我们调用此方法时，给常量形参赋值一个实参。一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值。- static final用来修饰属性：表示是全局常量。<a name="WATJM"></a>## 4.5 abstract**abstract关键字的使用**- abstract：抽象- abstract可以用来修饰的结构：类、方法- abstract修饰类：抽象类- 此类不能实例化- 抽象类中一定有构造器。便于子类实例化时调用（涉及：子类对象实例化的全过程）。- 开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作。- abstract修饰方法：抽象方法- 抽象方法只有方法的声明，没有方法体。- 包含抽象方法的类一定是一个抽象类。反之，抽象类中可以没有抽象方法。- 若子类重写了父类中的所有抽象方法，则此子类可实例化。- 若子类没有重写父类中的所有抽象方法，则此子类也是一个抽象类，需要使用abstract修饰。**abstract使用上的注意点：**- abstract不能用来修饰：变量、构造器、代码块等结构。- abstract不能用来修饰私有方法、静态方法、final的方法、final的类。- 子父类中同名同参数的非static方法才考虑重写，如果是static的则不认为它们是重写。**抽象类的匿名子类**```javapublic class PersonTest {public static void main(String[] args) {method(new Student());//匿名对象Worker worker = new Worker();method1(worker);//非匿名的类非匿名的对象method1(new Worker());//非匿名的类匿名的对象System.out.println("********************");//创建了一匿名子类的对象：pPerson p = new Person(){@Overridepublic void eat() {System.out.println("吃东西");}@Overridepublic void breath() {System.out.println("好好呼吸");}};method1(p);System.out.println("********************");//创建匿名子类的匿名对象method1(new Person(){@Overridepublic void eat() {System.out.println("吃好吃东西");}@Overridepublic void breath() {System.out.println("好好呼吸新鲜空气");}});}public static void method1(Person p){p.eat();p.breath();}public static void method(Student s){}}class Worker extends Person{@Overridepublic void eat() {}@Overridepublic void breath() {}}
模板方法设计模式
解决的问题：在软件开发实现一个算法时，整体步骤很固定、通用，这些步骤已经在父类中写好了。但是某些部分异变，异变部分可以抽象出来，供不同子类实现。这就是一种模板模式。
4.6 return
使用范围：使用在方法体中
- 作用：1、结束方法。2、针对于有返回值类型的方法，使用 “return 数据” 返回所要的数据。
-
4.7 package
package 顶层包名.子包名;
作为Java源文件的第一条语句，指明该文件中定义的类所在的包。
4.8 import
import 包名. 类名;
- 用import语句来导入指定包层次下指定的类或接口，*表示导入全部类或接口。
- 声明在包的声明和类的声明之间。
- 如果使用的类或接口是java.lang包下定义的，则可以省略import结构。
- 如果使用的类或接口是本包下定义的，则可以省略import结构。
如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示。
4.9 instanceof
有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法，但是由于变量声明的是父类类型，导致编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。
- 如何才能调用子类特有的属性和方法呢？向下转型：使用强制转换符。使用强转时可能出现ClassCastException的异常
- instanceof关键字的使用：
a instanceof A：判断关键字a是否是类A的实例。如果是，返回true；如果不是，返回false。
如果x属于类A的子类B，x instanceof A值也为true。
- instanceof的使用情景
为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先进行instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型。
如果a instanceof A返回true。并且a instanceof B也返回true。则类B是类A的父类。
- 向下转型的几个问题
多态练习：
java.lang.Object
- Object类是所有Java类的根父类
- 数组也作为Object类的子类出现，可以调用Object类中声明的方法。
- 如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类
- Object类中的属性和方法具有通用性
- clone() 克隆一个新的对象
- finalize() 垃圾回收：当一个对象在堆空间中发现没有任何引用指向这个对象了，垃圾回收期就会回收这个对象。在一个对象被回收之前会调用这个方法。
- getClass() 获取当前对象的所属类。
- hashCode() 返回当前对象的hash值
- Object类无属性
- final、finally、finalize的区别
- Object只声明了一个空参构造器
- == 和 equals()的区别
- ==：是一个运算符
1. 可以使用在基本数据类型变量和引用数据类型变量中1. 如果比较的是基本数据类型的变量：比较的是两个变量保存的数据是否相等，不一定类型相等。如果比较的引用数据类型：比较的是两个对象的地址值是否相同，即两个引用是否指向同一个对象实体。1. == 符号使用时，必须保证符号左右两边的变量类型一致（可自动转换的基本数据类型除外），否则编译出错。
- equals()：
1. 是一个方法，而非运算符1. 只能适用于引用数据类型1. Object类中的equals()的定义： public boolean equals(Object obj) {return (this == obj);}
- 说明：
- Object类中定义的equals()和==的作用是相同的：比较的是两个对象的地址值是否相同。
- 像String、Date、File、包装类等都重写了Object类中的equals()方法。重写以后，比较的不是两个引用的地址是否相同，而是比较两个对象的“实体内容（内部的属性）”是否相同。
- 通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的“实体内容”是否相同。那么我们就需要对Object类中的equals()进行重写。看举例
- 重写的原则：比较两个对象的实体内容是否相同。
- ==：是一个运算符
- Object类中toString()的使用
基本数据类型、包装类、String三者之间的转换
基本数据类型—->包装类：1、调用包装类的构造器 ；2、调用包装类的valueOf()方法；3、自动装箱
@Testpublic void test1(){int num1 = 10;// System.out.println(num1.toString());Integer in1 = new Integer(num1);System.out.println(in1.toString());//调用valueOf()方法Integer aa = Integer.valueOf(num1);Integer in2 = new Integer("123");System.out.println(in2.toString());//报异常// Integer in3 = new Integer("123abc");// System.out.println(in3.toString());Float f1 = new Float(12.3f);Float f2 = new Float("12.3");System.out.println(f1);System.out.println(f2);Boolean b1 = new Boolean(true);Boolean b2 = new Boolean("TrUe");System.out.println(b2);Boolean b3 = new Boolean("true123");System.out.println(b3);//false：忽略大小写之后只要不是true，就会认为是falseOrder order = new Order();System.out.println(order.isMale);//falseSystem.out.println(order.isFemale);//null}
包装类—->基本数据类型：调用包装类的xxxValue()
@Testpublic void test2(){Integer in1 = new Integer(12);int i1 = in1.intValue();System.out.println(i1 + 1);Float f1 = new Float(12.3);float f2 = f1.floatValue();System.out.println(f2 + 1);}
JDK5.0新特性：自动装箱与自动拆箱
- 装箱：将基本类型用它们对应的引用类型包装起来。
- 拆箱：将包装类型转换为基本数据类型
- 从字节码中，发现装箱其实就是调用了包装类的valueOf()方法，拆箱其实就是调用了 xxxValue()方法。
Integer i = 10等价于Integer i = Integer.valueOf(10)int n = i等价于int n = i.intValue()@Testpublic void test3(){// int num1 = 10;// //基本数据类型-->包装类的对象// method(num1);//自动装箱：基本数据类型 --->包装类int num2 = 10;Integer in1 = num2;//自动装箱boolean b1 = true;Boolean b2 = b1;//自动装箱//自动拆箱：包装类--->基本数据类型System.out.println(in1.toString());int num3 = in1;//自动拆箱}public void method(Object obj){System.out.println(obj);}
基本数据类型、包装类—->String类型：调用String重载的valueof(Xxx xxx)
@Testpublic void test4(){int num1 = 10;//方式1：连接运算String str1 = num1 + "";//方式2：调用String的valueOf(Xxx xxx)float f1 = 12.3f;String str2 = String.valueOf(f1);//"12.3"Double d1 = new Double(12.4);String str3 = String.valueOf(d1);System.out.println(str2);System.out.println(str3);//"12.4"}
String类型—->基本数据类型、包装类：调用包装类的parseXxx(String s)方法
@Testpublic void test5(){String str1 = "123";//错误的情况：// int num1 = (int)str1;// Integer in1 = (Integer)str1;//可能会报NumberFormatExceptionint num2 = Integer.parseInt(str1);System.out.println(num2 + 1);String str2 = "true1";boolean b1 = Boolean.parseBoolean(str2);System.out.println(b1);}
public class InterviewTest {@Testpublic void test1() {Object o1 = true ? new Integer(1) : new Double(2.0);//三元运算符会统一类型，System.out.println(o1);// 1.0}@Testpublic void test2() {Object o2;if (true)o2 = new Integer(1);elseo2 = new Double(2.0);System.out.println(o2);// 1}@Testpublic void test3() {Integer i = new Integer(1);Integer j = new Integer(1);System.out.println(i == j);//false//Integer内部定义了IntegerCache结构，IntegerCache中定义了Integer[],//保存了从-128~127范围的整数。如果我们使用自动装箱的方式，给Integer赋值的范围在//-128~127范围内时，可以直接使用数组中的元素，不用再去new了。目的：提高效率Integer m = 1;Integer n = 1;System.out.println(m == n);//trueInteger x = 128;//相当于new了一个Integer对象Integer y = 128;//相当于new了一个Integer对象System.out.println(x == y);//false}}
7. 设计模式
7.1 MVC设计模式
MVC是常用的设计模式之一，将整个程序分为三个层次：视图模型层，控制器层，与数据模型层。这种将程序输入输出、数据处理，以及数据的展示分离开来的设计模式使程序结构变的灵活而且清晰，同时也描述了程序各个对象间的通信方式，降低了程序的耦合性。
7.2 单例(Singleton)设计模式
定义：所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。并且该类只提供一个取得其对象实例的方法。 如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构造器的访问权限设置为private，这样，就不能用new操作符在类的外部产生类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象， 静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象 的变量也必须定义成静态的
如何实现？
饿汉式：例如java.lang.Runtime
public class SingletonTest1 {public static void main(String[] args) {// Bank bank1 = new Bank();// Bank bank2 = new Bank();Bank bank1 = Bank.getInstance();Bank bank2 = Bank.getInstance();System.out.println(bank1 == bank2);}}//饿汉式class Bank{//1.私有化类的构造器private Bank(){}//2.内部创建类的对象//4.要求此对象也必须声明为静态的private static Bank instance = new Bank();//3.提供公共的静态的方法，返回类的对象public static Bank getInstance(){return instance;}}
懒汉式
public class SingletonTest2 {public static void main(String[] args) {Order order1 = Order.getInstance();Order order2 = Order.getInstance();System.out.println(order1 == order2);}}class Order{//1.私有化类的构造器private Order(){}//2.声明当前类对象，没有初始化//4.此对象也必须声明为static的private static Order instance = null;//3.声明public、static的返回当前类对象的方法public static Order getInstance(){if(instance == null){instance = new Order();}return instance;}}
- 饿汉式和懒汉式的区别
- 饿汉式：坏处：对象加载时间过长
- 懒汉式：好处：延迟对象的创建。目前坏处：线程不安全。—->到多线程内容时，再修改
- 单例模式的优点
- 由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时产生一个单例对象，然后永久驻留内存的方式来解决。
单例设计模式的应用场景
接口使用关键字 interface 来定义
- Java中，接口和类是并列的两个结构
- 如何定义接口：定义接口中的成员
- JDK7以前，只能定义全局常量和抽象方法
- 全局常量：public static final的。但是书写时可以省略不写，即接口中的所有成员变量都默认是由public static final修饰的。
- 抽象方法：public abstract的。但是书写时可以省略不写，即接口中的所有抽象方法都默认是由public abstract修饰的。
- JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法。
- 接口中定义的静态方法，只能通过接口来调用，接口的实现类创建的对象不可以调用。
- 通过实现类的对象，可以调用接口中的默认方法。如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法。
- 如果子类（或实现类）继承的父类和实现的接口中声明了同名同参数的方法，那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法。—->类优先原则，这里是针对于方法。
- 如果实现类实现了多个接口，而多个接口中定义了同名同参数的默认方法，那么在实现类没有重写此方法的情况下，报错。——>接口冲突。这就需要我们必须在实现类中重写此方法。
- 如何在子类（或实现类）的方法中调用父类、接口中被重写的方法？super.方法名()调用的是父类中声明的。接口名.super.方法名()调用的是接口中的默认方法。
- JDK7以前，只能定义全局常量和抽象方法
- 接口里面的默认方法和缺省有什么区别：缺省是权限修饰符里面的一种，声明时可以不用写。但是 默认方法时default，声明时必须要写上default。
- 接口中不能定义构造器，意味着接口不可以实例化。
- Java开发中，接口通过让类去实现（implements）的方式来使用。如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化。如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为抽象类。
- Java类可以实现多个接口——>弥补了java单继承的局限性。定义Java类的语法格式：先写extends，后写implements 。格式：class AA extends BB implements CC,DD,EE
- 接口和接口之间可以继承，而且可以多继承。
- 接口的具体使用，体现多态性。
- 接口，实际上可以看做是一种规范。
抽象类与接口有哪些共同点和区别：
代理模式：就是为其他对象提供一种代理以控制对这个对象的访问。
- 工厂模式：实现了创建者与调用者的分离。即将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。
若有收获，就点个赞吧
0 人点赞
