[Java知识库]Java的面向对象

Java的面向对象

1.java类及类的成员：属性，方法，构造器； 代码块，内部类

2.面向对象的三大特征：封装性，继承性，多态性

3.其他关键字：this，super，static，final，abstract，interface，package，import等

类 = 属性 + 方法
1.属性 = 成员变量 = field = 域，字段
2.行为 = 方法 = 成员方法 = 函数 = method
3.创建类的对象 = 类的实例化 = 实例化对象

类和对象的使用（面向对象思想的落地实现）
1.创建类，设计类的成员
2.创建类的对象
3.通过“对象.属性”或“对象.方法”调用对象的结构

对象的内存分析

类的成员之一属性

类中属性的使用

属性（成员变量） vs 局部变量
1.相同点：
1.1 定义变量的格式：数据类型 变量名 = 变量值
1.2 先声明，后使用
1.3 变量都有其对应的作用域

2.不同点：
2.1 在类中声明的位置的不同
属性：直接定义在类的一对{}内
局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量

2.2 关于权限修饰符的不同
属性：可以在声明属性时，指明其权限，使用权限修饰符。
常用的权限修饰符：private、public、缺省、protected —>封装性
目前，大家声明属性时，都使用缺省就可以了。
局部变量：不可以使用权限修饰符。

2.3 默认初始化值的情况：
属性：类的属性，根据其类型，都有默认初始化值。
整型（byte、short、int、long）：0
浮点型（float、double）：0.0
字符型（char）：0 （或’\u0000’）
布尔型（boolean）：false

引用数据类型（类、数组、接口）：null

局部变量：没有默认初始化值。
意味着，我们在调用局部变量之前，一定要显式赋值。
特别地：形参在调用时，我们赋值即可。

2.4 在内存中加载的位置：
属性：加载到堆空间中 （非static）
局部变量：加载到栈空间

return关键字的作用
1.结束方法
2.（返回数据）针对返回值类型的方法，使用“return 数据”方法返回数据

一，谈谈你对面向对象中类和对象的理解，并指出二者的关系？
类：对一类事务的描述，是抽象的，概念上的定义
对象：是实际存在的，该类事物的每个个体，因而称为实例（instance）
面向对象程序设计的重点是类的设计，，设计类，就是设计类的成员
二者的关系：对象是类派生（new）出来的

在开发中，我们跟客户查询进行交互，需要提供一个类，这个API给我们提供好了叫Scanner类，这就是类的概念
我们真正执行的时候，我需要创建Scanner的对象，通过这个对象来操作它的功能方法，去完成我们和客户的交互。

二，面向对象思想的体现一：类和对象的创建和执行操作有哪三步？
①创建类
②类的实例化
③调用对象的结构：“对象.属性”，“对象.方法”

三，面向对象与面向过程（理解）
1.面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做
2.面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做

四，万事万物皆对象
1.在java语言范畴中，我们都将功能，结构等封装到类中，通过类的实例化，来调用具体的功能结构
2.涉及到java语言与前端HTML，后端数据库交互时，前后端的结构在java层面交互时，都体现为类，对象

五，方法重载（Overload）
判断条件：同类同方法名参数列表不同
参数列表值得是（参数的个数/种类 参数的顺序）

六，方法的形参的传递机制
形参：方法定义时，声明的小括号内的参数
实参：方法调用时，实际传递给形参的数据

值传递机制：
如果参数是基本数据类型，此时实参赋给形参的是实参真是存储的数据值
如果参数是引用数据类型，此时实参给形参的是实参存储数据的地址值

面向对象的特征之一封装

封装：
程序设计追求“高内聚，低耦合”
高内聚：类的内部数据操作细节自己完成，不允许外部干涉
低耦合：仅对外暴露少量的方法用于使用
把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想

封装性
1.私有的属性，提供公共的（public）方法来获取get和设置set
2.不对外暴露的私有方法
3.单例模式。。。(构造器私有化)
4.如果不希望类在包外被调用，可以将类设置为缺省的

封装性的体现，需要权限修饰符来配合
1.Java规定的4中权限（从小到大排序）：private，缺省(default)，protected,public
2.4种权限可以用来修饰类及类的内部结构：属性，方法，构造器，内部类
修饰类的话，只能使用缺省，public

总结：Java提供了4种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的大小

类的成员之三 构造器

一，构造器（构造方法constructor）的使用:创建对象,给对象进行初始化
构造器不是方法，它就是创建对象的，独立的

constructor：建造。construction:CCB constructor:建设者
//创建类的对象： new+构造器
Person p = new Person();

二，说明：
1.如果没有显式的定义类的改造器的话，则系统默认提供一个空参的构造器
2.定义构造器的格式：权限修饰符 类型（【参数列表】）{}
public Person（）{
}
public Person（String name）{
}

3一个类中可以有多个构造器，一个类中定义多个构造器，彼此构成重载
4.我们显式的定义了类的构造器之后，系统就不再提供默认的空构造器
5.一个类中，至少会有一个构造器（拥有创建对象的能力）

总结：属性赋值的先后顺序

1. 默认初始化
2. 显式初始化（在属性的类中）
3. 构造器中赋值（有参构造器）
4. 通过“对象.方法”或“对象.属性”的方式，赋值（set方法。。。。）

JavaBean

JavaBean是一种Java语言写成的可重用的组件
所谓的JavaBean，是指符合以下标准的Java类：

• 类是公共的
• 有一个无惨的公共的构造器
• 有属性，且有对应的get，set方法

用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变。

关键字this

1.this可以用来修饰、调用: 属性、方法、构造器

2.this修饰属性和方法:
this理解为:当前对象或当前正在创建的对象

3.this调用构造器

• 我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中指定的其他构造器
• 构造器中不能通过"this(形参列表)"方式调用自己
  public Person（int age）{
  this(); //必须放在当前构造器的首行
  this.age = age;
  }

package关键字的使用

1.为了更好的实现项目中类的管理，提供包的概念
2.使用package声明类或接口所属的包，声明在原文件的首行
3.包，属于标识符，遵循标识符的命名规范
注意：同一个包下，不能命名同名的接口，类。

import关键字的使用

import：导入
1.在源文件中显示的使用import结构导入指定包下的类，接口
2.声明在包的声明和类的声明之间
3.同一个包下的类或接口不用import
4.import static :导入指定类或接口中的静态结构：属性或方法

MVC设计模式

面向对象的特征之二继承

一，继承性的好处

1. 减少了代码的冗余，提高了代码的复用性
2. 便于功能的扩展
3. 为之后多态性的使用，提供了前提

二，继承的格式：class A extends B{}

• A:子类，派生类，subclass
• B:父类，超类，基类，subperclass
  体现：子类A继承父类B，子类A中就获取了父类B中声明所有的属性和方法

私有也会被子类继承，只是因为权限，子类无法直接访问。
（儿子继承了父亲的银行卡，银行卡是私有属性，儿子不知道密码，需要通过父类中的public get（）方法获取，，获取了父类的所有属性（包括私有属性），只是不能直接调用）

一个子类只能有一个父类（java中类的单继承性），一个父类可以有多个子类

所有的java类（除java.lang.Object类之外）都直接或间接继承于java.lang.Object类

方法重写（override/overWrite）

1.重写：子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作
2.应用：重写以后，当创建子类对象以后，通过子类对象调用父类的同名同参的方法时，实际上执行的是子类重写父类的方法
3.重写的规定：

1. 子类重写的方法的方法名和形参列表与父类的被重写的方法名和参数列表相同

2. 子类重写的方法的权限修饰符不小于父类的被重写的方法的权限修饰符
   特殊情况：子类不能重写父类中声明为private权限的方法（私有方法不能被重写）

3. 返回值类型
   如果父类是void则子类也要是void；
   父类是A类型，则子类返回值类型可以是A类型或A的子类

4. 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型

子类和父类的同名同参的方法要么都声明为非static的（考虑重写），要么都声明为static的（不重写）

方法的重载(overload)和重写(override)的区别：

在开发中只需要注意：
重载：同一类中同名不同参
重写：父子类中同名同参
重载参数列表必须不同，重写参数列表必须相同

关键字：super

1. super理解为：父类的
2. super可以用来调用：属性，方法，构造器
3. super的使用：
   3.1 我们可以在子类的方法或构造器中。通过使用"super.属性或"super.方法"的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."
   3.2特殊情况:当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式,表明调用的是父类中声明的属性。
   3.3特殊情况:当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法。
4. super调用构造器
   4.1我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器
   4.2 "super(形参列表)“的使用，必须声明在子类构造器的首行!
   4.3我们在类的构造器中，针对于”“this(形参列表)“或"super(形参列表)“只能二选一，不能同时出现
   4.4在构造器的首行，没有显式的声明"this(形参列表)“或"super(形参列表)””，则默认调用的是父类中空参的构造器：super()
   4.5 在类的多个构造器中，至少有一个类的构造器中使用了"super(形参列表)”，调用父类中的构造器

this(形参列表)：本类重载的其它的构造器（首行）
super(形参列表)：调用父类中指定的构造器（首行 ，默认是super）

子类对象的实例化过程

1.从结果上看：（继承性）
子类继承父类后，就获取了父类中声明的属性或方法
创建子类的对象，在堆空间中，就会加载所有父类中声明的属性
2.从过程上来看
当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用其父类的构造器，进而调用父类的构造器，直到调用了java.lang.Object类中空参的构造器为止，正因为加载过所有的父类的结构，所以才可以看到内存中有父类中的结构，子类对象才可以考虑进行调用。
明确，虽然创建子类对象时，调用了父类的构造器，但是自始至终就创建了一个对象，即为new的子类对象

面向对象特征之三：多态

理解多态性：可以理解为一个事物的多种形态

父类的引用指向子类的对象

多态的使用：当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法————虚拟方法调用

虚拟方法调用(多态情况下)
子类中定义了与父类同名同参数的方法，在多态情况下，将此时父类的方法称为虚拟方法，父类根据赋给它的不同子类对象，动态调用属于子类的该方法。这样的方法调用在编译期是无法确定的。（编译看左，运行看右）

多态是编译时行为还是运行时行为?
运行时行为

1. 有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法

2. 总结：编译看左，运行看右，new谁执行谁

3. 多态性使用前提：
   类的继承关系，方法的重写

4. 为什么要有多态性？：

5. 对象的多态性，只适用于方法，不适用于属性
   属性的值（编译和运行都看左边）

谈谈你对多态性的理解：
1.实现代码的通用性
2.Object类中定义的public boolean equals(object obj){ }
JDBC:使用java程序操作(获取数据库连接、CRUD)数据库(MySQL、oracle、DB2、sQL Server)
3.抽象类、接口的使用肯定体现了多态性。（抽象类、接口不能实例化)

向上转型：（引用是父类，对象是子类）-- 多态；
向下转型:(引用 子类，对象 子类) – 本态，
多态性只针对虚拟方法调用(普通方法)

为什么使用向下转型：

• 有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法，但是由于变量声明为父类类型，导致编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用
• 如何才能调用子类特有的属性和方法？
• 向下转型：使用强制类型转换符
  Person p2 = new Man(); //使用强转时，有可能出现类型转换异常
  Man m1 = (Man)p2;

使用时的注意点:
使用强转时，可能出现classCastException的异常。
为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先进行instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型。

Instanceof关键字的使用

a instanceof A:判断对象a是否是类A的实例。如果是，返回true;如果不是，返回false。

使用情景：为了避免在向下转型时出现类型转换异常，我们在向下转型之前，先进行instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型。

如果a instanceof A 返回true， 则a instanceof B 也返回true。其只，类B是类A的父类

要求a所属的类与类A必须是子类和父类的关系，否则编译错误。

1.多态练习——重写方法

java.lang.object类

1.object类是所有Java类的根父类
2.如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.object类
3.object类中的功能(属性、方法)就具有通用性。
属性:无
方法: equals() / tostring() / getclass() /hashcode() / clone() / finalize()
wait() 、 notify( )、notifyAll()

4. Object类只声明了一个空参的构造器

JDK API 1.6

垃圾回收

1. 垃圾回收机制只回收VM堆内存里的对象空间。
2. 对其他物理连接，比如数据库连接、输入流输出流、Socket连接无能为力
3. 现在的JVM有多种垃圾回收实现算法，表现各异。
4. 垃圾回收发生具有不可预知性，程序无法精确控制垃圾回收机制执行。
5. 可以将对象的引用变量设置为null，暗示垃圾回收机制可以回收该对象。
6. 程序员可以通过System.gc()或者Runtime.getRuntime().gc()来通知系统进行垃圾回收，会有一些效果，但是系统是否进行垃圾回收依然不确定。
7. 垃圾回收机制回收任何对象之前，总会先调用它的finalize方法（如果覆盖该方法，让一个新的引用变量重新引用该对象，则会重新激活对象）。|
8. 永远不要主动调用某个对象的finalize方法，应该交给垃圾回收机制调用。

equals()方法

==与equals（）区别？

==运算符

1. 可以使用在基本数据类型变量和引用数据类型变量中
2. 如果比较的是基本数据类型变量：比较两个变量保存的数据是否相等（不一定类型相同）
   如果比较的是引用数据类型变量：比较两个对象的地址值是否相同，即两个引用是否指向同一个对象实体

equals()方法

1. 是一个方法，而非运算符
2. 只使用于引用数据类型
3. object类中equals()的定义

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

说明: Object类中定义的equals()和==的作用是相同的:比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体

4. 像String，Data，File，包装类等都重写了Object类中的equals()方法。重写后，比较的不是两个引用的地址是否相同，而是比较两个对象的“实体内容”是否相同

    public static void main(String[] args) {
        Date data1 = new Date(32432525324L);
        Date data2 = new Date(32432525324L);
        System.out.println(data1.equals(data2));//true

        String str1 = new String("hello");
        String str2 = new String("hello");
        System.out.println(str1.equals(str2));//true
        System.out.println(str1 == str2);  //false
}

5. 通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的“实体内容”是否相同。那么我们就需要对Object类中的equals()方法重写.
   重写的原则：比较两个对象的实体内容是否相同

toString()

1. 当我们输出一个对象的应用时，实际上就是调用当前对象的toString()方法

2. 像String，Date,File,包装类等都重写了Object类中的toString()方法
   使得在调用对象的toString()时，返回“实体内容”信息

3. 自定义类也可以重写toString()方法，当调用此方法时，返回对象的“实体内容”

Java中的JUnit单元测试

步骤;

1.创建Java类，进行单元测试。
此时的Java类要求:
①此类是public的 ②此类提供公共的无参的构造器
2.此类中声明单元测试方法。
此时的单元测试方法: 方法的权限是public,没有返回值，没有形参
3.此单元测试方法上需要声明注解:@Test,并在单元测试类中导入:import org.junit.Test;
4.声明好单元测试方法以后，就可以在方法体内测试相关的代码。

包装类(Wrapper)的使用

1.java提供了8种基本数据类型对应的包装类，使得基本数据类型的变量具有类的特征
2.掌握的:基本数据类型、包装类、String三者之间的相互转换

基本数据类型—>包装类:调用包装类的构造器 (对象参数）
包装类—>基本数据类型:调用包装类x×x的x×xValue() （方便做±*/运算）

JDK 5.0新特性:自动装箱与自动拆箱

基本数据类型、包装类—>String类型调用String重载的valueOf(Xxx Xxx)

String类型—>基本数据类型、包装类:调用包装类的parseXxx(String s)

测试：

三元式中 表达式1和表达式2类型不同时
1.一种类型为char,short,byte,另一种为int常量，而且该常量能被前三种类型表示，则返回的是前三种的类型；

2.若int类型是变量，则会将操作数类型提升，返回类型为类型提升后的类型。

    System.out.println(true ? 97 : 'a'); //a
    System.out.println(true ? 1 : 2.0); //1.0
    System.out.println(true ? 2.0 : 1);  //2.0

• Integer内部定义了IntegerCache结构，IntegerCache中定义了Integer[],保存了从-128 ~127 范围的整数。
• 如果我们使用自动装箱的方式，给Integer赋值的范围在 -128~127范围内时，可以直接使用数组中的元素，不用再去new了。目的:提高效率

1.为什么要有包装类（封装类）
为了使基本数据类型的变量具有类的特征，引入包装类。

static关键字的使用

1.static：静态的
2.static可以来修饰：属性，方法，代码块，内部类
3.使用static修饰属性:静态变量
3.1属性，按是否使用static修饰，又分为:静态属性vs非静态属性(实例变量)

• 实例变量:我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改。

• 静态变量:我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。

  3.2 static修饰属性的其他说明:

• 静态变量随着类的加载而加载。可以通过"类．静态变量"的方式进行调用

• 静态变量的加载要早于对象的创建。

• 由于类只会加载一次，则静态变量在内存中也只会存在一份:存在方法区的静态域中

3.3 静态属性举例：System.out; Math.PI;

4.使用static修饰方法：静态方法
① 随着类的加载而加载，可以通过"类.静态方法"的方式进行调用
②

③ 静态方法中，只能调用静态的方法或属性
非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性

5. static注意点：
   5.1 在静态的方法内，不能使用this关键字、super关键字
   5.2 关于静态属性和静态方法的使用，大家都从生命周期的角度去理解。

6. 开发中，如何确定一个属性是否要声明为static的？

   属性是可以被多个对象所共享的，不会随着对象的不同而不同的。
   类中的常量也常常声明为static

   开发中，如何确定一个方法是否要声明为static的？

   操作静态属性的方法，通常设置为static的
   工具类中的方法，习惯上声明为static的。 比如：Math、Arrays、Collections

静态的方法属性在类加载的时候被创建，静态的方法可以调用静态的属性，
非静态的方法属性在对象实例化的时候被创建，可以调用静态的方法和属性

设计模式

设计模式是在大量的实践中总结和理论化之后优选的代码结构，编码风格，以及解决问题的思考方式（套路）

单例（Singleton）设计模式
所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。

单例模式的优点：由于单例模式只生成一个实例，减少了系统性能开销。

实现步骤：
1.私有化类的构造器
2.内部创建类的对象，要求此对象也必须声明为静态的
3.提供公共的静态的方法，返回类的对象

根据实例化对象的时刻不同分为：饿汉式和懒汉式

饿汉式：初始化的时候实例化对象

懒汉式：第一次调用的时候创建,(（每次被调用先判断是否nul，如果对象已经被实例化，直接用l）)

饿汉式：
好处：线程安全的
坏处：对象加载时间长
懒汉式：
好处：延迟对象的创建
坏处：目前是线程不安全的 ------>到多线程内容，
懒汉式相对好一点，用的时候才被创建，饿汉式不管用不用都在类加载时候创建对象

单例模式设计模式----应用场景

类的成员之四：代码块（初始化块）

1. 代码块的作用：用来初始化类、对象

2. 代码块如果有修饰的话，只能使用static.

3. 分类：静态代码块 vs 非静态代码块

4. 静态代码块

   内部可以有输出语句
   随着类的加载而执行,而且只执行一次
   作用：初始化类的信息
   如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
   静态代码块的执行要优先于非静态代码块的执行
   静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构

5. 非静态代码块

   内部可以有输出语句
   随着对象的创建而执行
   每创建一个对象，就执行一次非静态代码块
   作用：可以在创建对象时，对对象的属性等进行初始化
   如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
   非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性，非静态的方法

总结：有父及子，静态先行
先执行父类的静态代码块–>直接父类的静态代码块—>本类的静态代码块，然后父类的代码块–>父类的无参构造器–>直接父类的代码块–>无惨构造器—>本类的代码块–>无惨构造器

对属性可以赋值的位置:
①默认初始化
②显式初始化
③构造器中初始化
④有了对象以后，可以通过"对象.属性"或"对象.方法"的方式，进行赋值
⑤在代码块中赋值

先后顺序：①→②/⑤→③→④

关键字：final

final:最终的

1. final可以用来修饰的结构：类、方法、变量（属性，局部变量）

2. final 用来修饰一个类:此类不能被其他类所继承。
   比如：String类、System类、StringBuffer类
   (该有的功能都有了，无需扩展功能，不用去继承，想用就用，不用拉到)

3. final 用来修饰方法：表明此方法不可以被重写
   比如：Object类中getClass();

4. final 用来修饰变量：此时的"变量"就称为是一个常量
   4.1 final修饰属性：可以考虑赋值的位置有：显式初始化、代码块中初始化、构造器中初始化
   4.2 final修饰局部变量：
   尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值
   以后，就只能在方法体内使用此形参，但不能进行重新赋值。

static final 用来修饰属性：全局常量

用来修饰方法：直接通过类来调用这个方法不能被重写

总结：
1.static 修饰的属性，相较于实例变量，有哪些特别之处（创建，调用，存储）

• 随着类的加载而加载;早于对象的创建;
• 只要权限允许，可以通过”对象.static属性”的方式进行调用;
• 存在于方法区的静态域

abstract关键字的使用

1.abstract:抽象的
2.abstract可以用来修饰的结构:类、方法
3. abstract修饰类:抽象类

此类不能实例化
抽象类中一定有构造器，便于子类实例化时调用（涉及:子类对象实例化的全过程)
开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作

4. abstract修饰方法:抽象方法

抽象方法只能有方法的声明，没有方法体
包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象的方法。
若子类重写了父类中的所有的抽象方法后，此子类方可实例化
若子类没有重写了父类中的所有的抽象方法后，此子类也是抽象类不能被实例化

abstract使用上的注意点：
1.abstract不能用来修饰：属性，构造器等结构
2.abstract不能用来修饰私有方法，静态方法 ，final的方法，final的类

举例： 父类中有写功能实在没有办法指明，子类反正又要重写了，就给该功能抽象成抽象方法，把该类设置成抽象类

总结：
抽样类不能被实例化（只能被继承），抽样方法所属的类一定是抽样类

继承抽样类的子类要不把每个抽样方法重写，要不也是一个抽样类

匿名子类的对象

创建匿名子类的匿名对象

匿名的意义就是只用一次

模板方法设计模式(TemplateMethod)

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式。

1. 解决的问题:

当功能内部一部分实现是确定的，一部分实现是不确定的。这时可以
把不确定的部分暴露出去，让子类去实现。

换句话说，在软件开发中实现一个算法时，整体步骤很固定、通用，这些步骤已经在父类中写好了。但是某些部分易变，易变部分可以抽象出来，供不同子类实现。这就是一种模板模式。

2. 举例：

/**
 * 抽象类的应用，模板方法的设计模式
 */
class templateTest{
    public static void main(String[] args) {
        SubTemplate subTemplate = new SubTemplate();
        subTemplate.spendTime();
    }
}
public abstract class Template {
    //计算某代码执行所需要花费的时间
    public void spendTime(){
        long start = System.currentTimeMillis();
        this.code();//不确定的部分，易变得部分
        long end = System.currentTimeMillis();
        System.out.println();
        System.out.println("程序运行花费的时间为："+(end-start)+"毫秒");
    }
    public abstract void code();
}
class SubTemplate extends Template{
    @Override
    public void code() {
        for (int i = 2; i < 1000; i++) {
            int flag = 0;
            for (int j=2;j<=Math.sqrt(i);j++){
                if (i%j==0){
                    flag = 1;
                }
            }
            if (flag==0){
                System.out.print(i+" ");
            }
        }
    }
}

接口interface

• 一方面，有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果
• 另一方面，有时必须从几个类中抽取出一些共同的行为特征，而它们之间又没有is-a的关系，仅仅是具有相同的行为特征而已。例如:鼠标、键盘、打印机、扫描仪、摄像头、充电器、MP3机、手机、数码相机、移动硬盘等都支持USB连接。
• 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要…则必须能…”的思想。继承是一个"是不是"的关系，而接口实现则是"能不能"的关系。
• 接口的本质是契约，标准，规范，就像我们的法律一样。制定好后大家都要遵守。

接口的使用：
1.接口使用interface来定义
2.Java中，接口和类是并列的两个结构
3.如何定义接口：定义接口中的成员
3.1JDK7及以前:只能定义全局常量和抽象方法

>全局常量:public static final的）（可以省略不写）
>抽象方法:public abstract的

3.2JDK8:除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法(略)

4.接口中不能定义构造器的。意味着接口不可以实例化
5.Java开发中，接口通过让类去实现（implements）的方法来使用。
如果实现类覆盖了接口中的所有抽样方法，则此实现类就可以实例化
如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类
6.Java类可以实现多个接口---->弥补了Java单继承性的局限性
格式： class AA extends BB implements CC,DD,EE{}

7.接口与接口之间可以继承，而且可以多继承
8.接口的具体使用，体现了多态性
9.接口，实际上就可以看做一种规范
10.开发中，体会面向接口编程！

接口定义的一种规范，面向接口编程，使得代码更具有通用性或可移植性

代理模式

代理模式是Java开发中使用较多的一种设计模式。代理设计就是为其他对象提供一种代理以控制对这个对象的访问。

代理类和被代理类都需要实现这个接口，通过代理类的对象调用实现接口中的抽象方法时，里面包含了被代理对象同名的方法的调用。

工厂模式

1．解决的问题
实现了创建者与调用者的分离，即将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。
2．具体模式
简单工厂模式。用来生产同一等级结构中的任意产品。(对于增加新的产品，需要修改已有代码)工厂方法模式:用来生产同一等级结构中的固定产品。(支持增加任意产品)
抽象工厂模式。用来生产不同产品族的全部产品。(对于增加新的产品，无能为力﹔支持增加产品族)
3.核心本质:
实例化对象，用工厂方法代替new操作。
将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。

Java8中关于接口的改进

Java8新特性
知识点1：接口中定义的静态方法，只能通过接口来调用
知识点2：通过实现类的对象，可以调用接口中的默认方法
如果实现类重写了接口中的默认方法，调用时，任然调用的是重写以后的方法
知识点3：如果子类（或实现类）继承的父类和实现的接口中声明了同名同参数的方法，那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法。------>类优先原则
知识点4：如果实现类实现了多个接口，而这多个接口中定义了同名同参的默认方法，那么在实现类没有重写此方法的情况下，报错。------>接口冲突
这就需要我们必须在实现类中重写此方法
知识点5：如何在子类（或实现类）的方法中调用父类，接口中被重写的方法

类的内部成员之五：内部类

1. Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B就是外部类

2. 内部类的分类：成员内部类（静态，非静态） 和局部内部类（方法内，代码块内，构造器内）

3. 成员内部类:
   一方面，作为外部类的成员;

   调用外部类的结构
   可以被static修饰
   可以被4种不同的权限修饰

   另一方面，作为一个类:

   类内可以定义属性、方法、构造器等
   可以被final修饰，表示此类不能被继承。言外之意，不使用final，就可以被继承
   可以被abstract修饰

   4. 关注如下的3个问题

   4.1 如何实例化成员内部类的对象
   4.2如何在成员内部类中区分调用外部类的结构
   4.3 开发中局部内部类的使用

总结

1. abstract能修饰哪些结构? 修饰以后，有什么特点?,

类、方法。
类不能实例化，提供子类
抽象方法，只定义了一种功能的标准。具体的执行，需要子类去实现。

2. 接口是否能继承接口?抽象类是否能实现(implements)接口?抽象类是否能继承非抽象的类?,
   能，能，能

3. 抽象类和接口有哪些共同点和区别?

抽象类：类中的有的东西它都可以有，还可以有抽象方法
接口：JDK7及以前只能有：全局变量和抽样方法 JDK8以后可以添加静态静态方法和默认方法，JDK9可以定义私有方法。

相同点:不能实例化（都可以包含抽样方法的），都可以被继承

不同点:抽象类:有构造器。接口:不能声明构造器
类：单继承 接口：多继承
类与接口：多实现

抽象类和接口都不能够实例化，但可以定义抽象类和接口类型的引用。一个类如果继承了某个抽象类或者实现了某个接口都需要对其中的抽象方法全部进行实现，否则该类仍然需要被声明为抽象类。接口比抽象类更加抽象，因为抽象类中可以定义构造器，可以有抽象方法和具体方法，而接口中不能定义构造器而且其中的方法全部都是抽象方法。抽象类中的成员可以是private、默认、protected、public的，而接口中的成员全都是public的。抽象类中可以定义成员变量，而接口中定义的成员变量实际上都是常量。有抽象方法的类必须被声明为抽象类，而抽象类未必要有抽象方法。