1、概述：
多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只有继承那个类即可。
多个类可以称为子类，单独这个类称为父类或超类。
子类可以直接访问父类中的非私有的属性和行为。
通过extends关键字让类与类之间产生继承关系。
class SubDemo extends Demo{}
图解：
2、继承的好处和弊端：
好处：
（1）提高了代码的复用性
（2）让类与类之间产生了关系，给第三个特征多态提供了前提。
弊端：打破了封装性。
3、java单继承
*java中支持单继承。不直接支持多继承，但对C++的多继承机制进行改良。
**一个类只能有一个父类，不可以有多个父类
*单继承：一个子类只能有一个直接父类。
*多继承：一个子类可以有多个直接父类（java中不允许，已改良）；
不直接支持，因为多个父类中有相同成员，会产生调用的不确定性。
在java中是通过“多实现”的方式来体现。
4、定义继承需要注意：
（1）不要仅为了获取其他类中某个功能而去继承。
（2）类与类之间要有所属（“is a”）关系，xx1是xx2的一种。
*java支持多层（多重）继承
C继承B,B继承A
就会出现继承体系。
**当要使用一个继承体系时：
***查看该体系中顶层类，了解该体系的基本功能
***创建体系中的最子类对象，完成功能的使用。
5、什么时候定义继承呢？
*当类与类之间存在着所属关系的时候，就定义继承。xxx是yyy中的一种。xxx extends yyy
6、super关键字：
this代表本类对象的引用
super代表父类的内存空间的标识
*在子父类中，成员的特点体现：
成员变量、成员函数、构造函数
成员变量：
当本类的成员和局部变量同名用this区分。
当子父类中的成员变量同名用super区分父类。
子类要调用父类构造函数时，可以使用super语句。
成员函数：
当子父类中出现成员函数一模一样的情况，会运行子类的函数。
这种现象，称为覆盖操作。这是函数在子父类中的特性：
（1）重载。同一个类中。
（2）覆盖。子类中，覆盖也称为重写，复写。
7、函数覆盖：
（1）定义：
子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重写或复写。
覆盖是函数的特性之一，只有函数才有覆盖
父类中的私有方法不可以被覆盖。
在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取。
（2）什么时候使用覆盖操作？
*当对一个类进行子类的扩展时，子类需要保留父类的功能声明，但是要定义子类中该功能的特有内容时，就使用覆盖操作完成。
*当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。
（3）子父类中的构造函数的特点：
*在子类构造对象时发现，访问子类构造函数时，父类也运行了，为什么？
原因：在子类的构造函数中第一行有一个默认的隐式语句：super()；
super();//调用的就是父类中空参数的构造函数。
图解：
（4）子类的实例化过程：子类中所有的构造函数默认都会访问父类中的空参数的构造函数。
*为什么子类实例化时要访问父类中的构造函数呢？
因为子类继承了父类，获取到了父类中的内容（属性），所以在使用父类内容之前，要先看父类如何对自己的内容进行初始化的。所以子类在构造对象时，必须访问父类的构造函数。为了完成这个必须的动作，就在子类的构造函数中加入了super()语句(在第一行)。
子类会继承父类中的数据，所以要先明确父类是如何对这些数据初始化的。
*如果父类中没有定义空参数构造函数，那么子类的构造函数必须用super明确要调用父类中的哪个构造函数。 同时，子类的构造函数中如果使用了this调用了本类的构造函数时，那么super就没有了，因为super和this都只能定义在第一行，所以只能有一个，但是可以保证的是，子类中肯定会有个其他的构造函数访问父类的构造函数。
*注意：super语句必须要定义在子类构造函数的第一行。因为，父类初始化动作要先完成。
（5）覆盖注意事项：
*子类方法覆盖父类方法时，子类权限必须要不小于父类的权限。
*静态只能覆盖静态，或被静态覆盖。
图解：
8、设计模式：
对问题行之有效的解决方式。其实它是一种思想。
（1）单例设计模式：
解决的问题：就是可以保证一个类在内存中的对象唯一性。
比如对于多个程序使用同一个配置信息对象时，就需要保证该对象的唯一性。
*如何保证对象唯一性？
**不允许其他程序用new创建该类对象；
**在该类中创建一个本类实例；
**对外提供一个方法让其他程序可以获取该对象。
*步骤：
**私有化该类的构造函数
**通过new在本类中创建一个本类对象
**定义一个公有的方法，将创建的对象返回。
代码体系：单例模式有饿汉式和懒汉式
//饿汉式
class Single{//类一加载，对象就已经存在了。
private static Single s = new Single();
private Single(){}
public static Single getInstance(){
return s;
}
}
//懒汉式
class Single2{//类加载进来，没有对象，只有调用了getInstance方法时，才会创建对象。//延迟加载形式。
private static Single2 s = null;
private Single2(){}
public static Single2 getInstance(){
if(s==null)
s = new Single2();
return s;
}
}
图解：
9、对象实例化过程
例：Person p = new Person();
*JVM会读取指定的路径下的Person.class文件，加载进内存，并会先加载Person的父类（如果有直接的父类的情况下）
*在堆内存中开辟空间，分配地址；（如果有静态代码块的话，会先执行静态代码块，再开辟空间，因静态先于对象存在）
*并在对象空间中，对对象中的属性进行默认初始化
*调用对应的构造函数进行初始化（如果类中属性有赋值，则会先显示初始化，然后才是构造函数初始化）
*在构造函数中，第一行会先调用父类中的构造函数进行初始化，
*父类初始化完毕后，再对子类的属性进行显示初始化
*再进行子类构造函数的特定初始化
*初始化完毕后，将地址值赋值给引用变量
图解：
10、final关键字
*final是一个修饰符，可以修饰类，方法，变量
*final修饰的类不可被继承；
*final修饰的方法不可以被覆盖
*final修饰的变量是一个常量，只能赋值一次。
*内部类只能访问被final修饰的局部变量
**final固定的是显示初始化，不固定默认初始化
*为什么要用final修饰变量？
其实在程序中如果一个数据是固定的，那么直接使用这个数据就可以了，但是这样阅读性差，所以该数据起个名字，而且这个变量名称的值不能变化，所以加上final固定。
写法规范：常量所有字母都大写，多个单词，中间用下划线_连接
11、抽象类
（1）概述：java中的类没有足够的信息来描述一个具体的对象，这个类就是一个抽象类。
抽象类就是对一系列看上去不同，但本质相同的具体概念的抽象。
（2）抽象：笼统，模糊，看不懂，不具体。
抽象定义：
*抽象就是从多个事物中将共性的，本质的内容抽取出来。
（3）抽象类：
java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类就是抽象类。
（4）抽象方法的由来：
*多个对象都具备相同的功能，但是功能具体内容有所不同，那么在抽取过程中，只抽取了功能定义，并未抽取功能主体，那么只有功能声明，没有功能主体的方法称为抽象方法。
*例如：狼和狗都有吼叫的方法，可是吼叫的内容是不一样的，所以抽象出来的犬科虽然有吼叫功能，但是并不明确吼叫的细节。
（5）抽象类特点：
*抽象方法只有方法声明，没有方法体，定义在抽象类中。
*格式:修饰符 abstract 返回值类型 函数名（参数列表）；
*方法只有声明没有实现时，该方法就是抽象方法，需要被关键字abstract修饰，抽象方法必须定义在抽象类中，该类必须也被abstract修饰。
*抽象类不可以被实例化，也就是不可以用new创建对象。
**为什么？因为调用抽象方法没意义。注：抽象方法只有声明没有实现，调用它无意义。
**抽象类是具体事物抽取出来的，本身是不具体的，没有对应的实例。
**例如：犬科是一个抽象的概念，真正存在的是狼和狗
**而且抽象类即使创建了对象，调用抽象方法也没有意义。
*抽象类必须有其子类覆盖了所有抽象方法后，该子类才可以实例化。（抽象类通过其子类实例化，而子类需要覆盖掉抽象类中所有的抽象方法后才可以创建对象，否则该子类也是抽象类）
（6）问题：
*抽象类中有构造函数吗？
有，用于给子类对象进行初始化
*抽象类可以不定义抽象方法吗？
可以的。但是很少见，目的就是不让该类创建对象，AWT的适配器对象就是这种类。通常这个类中的方法有方法体，但是却没有内容。
*抽象关键字不可以和那些关键字共存?
private不行，子类必须覆盖父类方法后才能实例化，私有使父类方法隐藏不能被子类覆盖，矛盾。
static 不行，该修饰符修饰后的方法可被类名直接调用，无需创建对象，但抽象方法没有方法体，直接调用该方法没有意义。
final 不行，该修饰符修饰的方法不能被覆盖，使子类不能实例化。
*抽象类和一般类的区别。
**相同点：
抽象类和一般类都是用来描述事物的，都在内部定义了成员；
**不同点：
***一般类有足够的信息描述事物
抽象类描述事物的信息有可能不足
***一般类中不能定义抽象方法只能定义非抽象方法
而抽象类中可定义抽象方法，同时也可以定义非抽象方法
***一般类可以被实例化
抽象类不可以被实例化。（只能由其子类覆盖实例化）
**抽象类一定是个父类吗？
是的。因为需要子类覆盖其方法后才可以对子类实例化。
（7）雇员示例：
需求：公司中程序员有姓名，工号，薪水，工作内容。
项目经理除了有姓名，工号，薪水，还有奖金，工作内容。
对给出需求进行数据建模。
分析：
在这个问题领域中，先找出涉及的对象。
通过名词提炼法。
程序员：
属性：姓名，工号，薪水、
行为：工作。
经理：
属性：姓名，工号，薪水，奖金。
行为：工作。
程序员和经理不存在着直接继承关系，
但是程序员和经理却具有共性内容。
可以进行抽取。因为他们都是公司的雇员
可以将程序员和经理进行抽取.建立体系.
//描述雇员。
abstract class Employee{
private String name;
private String id;
private double pay;
Employee(String name,String id,double pay){
this.name = name;
this.id = id;
this.pay = pay;
}
public abstract void work();
}
//描述程序员。
class Programmer extends Employee{
Programmer(String name,String id,double pay){
super(name,id,pay);
}
public void work(){
System.out.println("code...");
}
}
//描述经理。
class Manager extends Employee{
private int bonus;
Manager(String name,String id,double pay,int bonus){
super(name,id,pay);
this.bonus = bonus;
}
public void work(){
System.out.println("manage");
}
}
12、接口
（1）定义：
*当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用另一种形式定义和表示，就是接口 interface
*定义接口使用的是interface，不是class。
*格式：
interface {}
（2）接口中的成员修饰符是固定的。
*全局常量：public static final
*抽象方法：public abstract
*发现接口中的成员都是public的。
由此得出结论，接口中的成员都是公共的权限。
（3）接口的特点：
*接口是对外暴露的规则。
*接口是程序的功能扩展。
*接口的出现降低耦合性。
*接口可以用来多实现。
*类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。
*接口与接口之间可以有继承关系,并且可以是多继承。
如：
interface CC{
void show();
}
interface MM{
void method();
}
interface QQ extends CC,MM{//接口与接口之间是继承关系，而且接口可以多继承。
void function();
}
class WW implements QQ{
//覆盖3个方法。
public void show(){}
public void method(){}
public void function(){}
}
（4）接口的出现，避免了单继承的局限性
*接口不可以实例化。只能由实现了接口的子类并覆盖了接口中所有的抽象方法后，该子类才可用实例化，否则，这个子类就是一个抽象类。
*在java中不直接支持多继承，因为会出现调用的不确定性。所以java将多继承机制进行改良，在java中变成多实现。
（5）抽象类和接口的异同点：
*相同点：都是不断向上抽取而来的。
*不同点：
**抽象类需要被继承，而且只能单继承
接口需要被实现，而且可以多实现
**抽象类中可以定义抽象方法和非抽象方法，子类继承后可以直接使用非抽象方法
接口只能定义抽象方法，必须由子类去实现。
**抽象类的继承是is a关系，在定义该体系的基本共性内容
接口的实现是like a关系，在定义体系的额外功能。
（6）接口举例：笔记本接口的例子：
/*
笔记本电脑使用。
为了扩展笔记本的功能，但日后出现什么功能设备不知道。
定义一个规则，只要日后出现的设备都符合这个规则就可以了。
规则在java中就是接口。
*/
interface USB{// 暴露的规则。
public abstract void open();
public abstract void close();
}
class BookPC{
public static void main(String[] args){
useUSB(new UPan());//功能扩展了。
useUSB(new UsbMouse());
}
//使用规则。
public static void useUSB(USB u){//接口类型的引用，用于接收(指向)接口的子类对象。USB u= new UPan();
if(u!=null){
u.open();
u.close();
}
}
}
//一年后。------------------------------
//实现规则。
//这些设备和电脑的耦合性降低了。
class UPan implements USB{
public void open(){
System.out.println("upan open");
}
public void close(){
System.out.println("upan close");
}
}
class UsbMouse implements USB{
public void open(){
System.out.println("UsbMouse open");
}
public void close(){
System.out.println("UsbMouse close");
}
}
