一、面向对象（继承）
继承：
1.提高了代码的复用性。
2.让类与类之间产生了关系。有了这个关系，才有了多态的特性。
注意：千万不要为了获取其它类的功能，而简化代码进行继承。必须是类与类之间有所属关系才可以继承。
/*
将学生和工人的共性描述提取出来，单独进行描述。
*/
class Person//人类（父类）
{
String name;
int age;
}
class Student extends Person//学生类继承人类（子类）
{
void study()
{
System.out.println("good study");
}
}
class Worker extends Person//工人类继承人类（子类）
{
void work()
{
System.out.println("good work");
}
}
Java语言中：
1.Java只支持单继承，不支持多继承。
因为多继承容易出现安全隐患:当多个父类中定义了相同的功能，当功能内容不同时，子类对象不确定要运行哪一个。但是Java保留了这种机制，并用多实现来表示。
2.Java支持多层继承，也就是一个继承体系。
如何使用一个继承体系中的功能？
想要使用体系，先查阅体系中父类的描述，因为父类中定义的是该类中的共性内容。通过了解共性功能，就可以知道该体系的基本功能。那么这个体系已经可以基本使用了。
那么在具体调用时，要创建子类的对象，那是因为：
1.有可能父类不能创建对象（抽象类）。
2.创建子类对象可以使用更多的功能，包括基本的也包括特有的。
总之：查阅父类功能，创建子类对象来使用功能。
二、面向对象（聚集关系）
继承：指的是一个类（称为子类）继承另外的一个类（称为基类）的功能，并增加它自己的新功能的能力，继承是类与类之间最常见的关系。类图中继承的表示方法是从子类拉出一条闭合的、单键头（或三角形）的实线指向基类。
关联：指的是模型元素之间的一种语义联系，是类之间的一种很弱的联系。关联可以有方向，可以是单向关联，也可以是双向关联。可以给关联加上关联名来描述关联的作用。关联两端的类也可以以某种角色参与关联，角色可以具有多重性，表示可以有多少个对象参与关联。可以通过关联类进一步描述关联的属性、操作以及其他信息。关联类通过一条虚线与关联连接。对于关联可以加上一些约束，以加强关联的含义。
聚合：指的是整体与部分的关系。通常在定义一个整体类后，再去分析这个整体类的组成结构。从而找出一些组成类，该整体类和组成类之间就形成了聚合关系。例如一个航母编队包括海空母舰、驱护舰艇、舰载飞机及核动力攻击潜艇等。需求描述中“包含”、“组成”、“分为…部分”等词常意味着聚合关系。
组合：也表示类之间整体和部分的关系，但是组合关系中部分和整体具有统一的生存期。一旦整体对象不存在，部分对象也将不存在。部分对象与整体对象之间具有共生死的关系。
聚合关系是“has-a”关系，组合关系是“contains-a”关系；聚合关系表示整体与部分的关系比较弱，而组合比较强；聚合关系中代表部分事物的对象与代表聚合事物的对象的生存期无关，一旦删除了聚合对象不一定就删除了代表部分事物的对象。组合中一旦删除了组合对象，同时也就删除了代表部分事物的对象。
聚合与组合的区别：
聚合：分散的聚集到一起。组合：几个独立部分组成的整体。由此可见，聚合就像将不同的水果放到一个玻璃果盘里，玻璃果盘摔坏，并不影响水果。
三、面向对象（子类和父类中变量的特点）
变量：如果子类中出现非私有的同名成员变量时，子类要访问本类中的变量，
用this关键字。子类要访问父类中的同名变量，用super关键字。
/*
子类和父类的成员变量特点：
*/
class Fu
{
int num=1;
}
class Zi extends Fu
{
int num=2;
void show()
{
System.out.println("子类："+this.num);//子类引用
System.out.println("父类："+super.num);//父类引用
}
}
class ExtendsDemo2
{
public static void main(String[] args)
{
Zi z=new Zi();
z.show();
}
}
四、面向对象（子类和父类中函数的特点）
当子类出现和父类同名的函数时，当子类对象调用该函数，会运行子类的函数，如同父类的同名函数被覆盖一样。这种情况是函数的重写（覆盖）。
当子类继承了父类，沿袭了父类的功能到子类中，子类虽然具备该功能，但功能的内容却和父类不一致。这时没有必要定义新功能，而是使用覆盖保留父类的功能定义并重写功能内容。
覆盖：
1. 子类覆盖父类，必须保证子类权限大于等于父类权限。
2. 静态只能覆盖静态。
注意：重载只看同名函数的参数列表，重写（覆盖）要保证子类和父类方法要一模一样。
/*
子类和父类的类成员函数特点：
*/
class Fu
{
void show()
{
System.out.println("父类中的show1");
}
}
class Zi extends Fu
{
void show()
{
super.show();
System.out.println("子类中的show2");
}
}
class ExtendsDemo2
{
public static void main(String[] args)
{
Zi z=new Zi();
z.show();
}
}
五、面向对象（子类和父类中构造函数的特点-子类实例化过程）
在对子类对象进行初始化时，父类的构造函数也会运行，那是因为子类的构造函数默认第一行有一条隐式的语句super();
super()：会访问父类中空参数的构造函数，并且子类中所有的构造函数默认第一行都是super();
为什么子类一定要访问父类中的构造函数？
因为父类中的数据子类可以直接获取，所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。子类在对象初始化时，要先访问一下父类中的构造函数，如果要访问父类中的指定构造函数，可以通过手动定义super语句的方式来指定。
注意：super语句一定要定义在子类构造函数的第一行。
结论：子类的所有的构造函数默认都会访问父类中空参数的构造函数，因为子类每一个构造函数内的第一行都有一句隐式super();
当父类中没有空参数的构造函数时，子类必须通过手动super()语句的形式来指定要访问父类中的构造函数。当然子类的构造函数第一行也可以手动指定this语句类访问本类中的构造函数，子类中至少会有一个构造函数会访问父类中的构造函数。
/*
子类和父类的类成员函数特点：
*/
class Fu
{
Fu()
{
System.out.println("父类构造函数");
}
}
class Zi extends Fu
{
Zi()
{
//super();
System.out.println("子类构造函数");
}
Zi(int x)
{
//super();
System.out.println("子类构造函数:"+x);
}
}
class ExtendsDemo2
{
public static void main(String[] args)
{
Zi z1=new Zi();
Zi z2=new Zi(4);
}
}
六、面向对象（final关键字）
final:一次赋值，终身不变。
作为一个修饰符：
1. 可以修饰类，函数，变量
2. 被final修饰的类不可被继承。为了避免被继承，被子类复写功能。
3. 被final修饰的方法不可以被复写。
4. 被final修饰的变量是一个常量，只能赋值一次。既可以修饰成员变量，又可以修饰局部变量。当在描述事物时，一些数据的值是固定的，为了增强阅读性，都给这些值起个名字。而这个值不需要改变，所以加上final修饰。作为常量：常量的书写规范都是所有字母大写，如果有多个单词组成，但此间通过_来连接。
5. 内部类定义在类中的局部位置上时，只能访问该局部被fianl修饰的局部变量。
七、面向对象（抽象类）
abstract:抽象
当多个类中出现相同功能，但是功能主体不同，这时可以进行向上抽取，只抽取
功能主体。
抽象类的特点：
1.抽象方法一定定义在抽象类中。
2.抽象方法和抽象类都必须被abstract关键字修饰。
3.抽象类不可以用new创建对象，因为调用抽象方法没意义。
4.抽象类中的方法要被使用，必须由子类复写其所有抽象方法后建立子类对象调用。如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类，所以需要给子类加上abstract关键字。
5.抽象类和一般类没有太大不同，该如何描述事物就如何描述事物，只不过该事物中出现一些看不懂的东西。这些不确定的部分，也是该事物的功能，需要明确出现，但是无法定义主体。
6.抽象类比一般类多了个抽象方法（函数）。
7.抽象类不可实例化。
特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。
练习：
/*
开发一个系统，需要对员工进行建模，员工包含3个属性：
姓名，工号以及工资。经理除员工具有的属性外，另外还有一个奖金属性。
使用继承思想设计出员工类和经理类。要求类中提供必要的方法进行属性
访问。
*/
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 String getName(){return name;}
public String getId(){return id;}
public double getPay(){return pay;}
public abstract void work();//抽象方法
}
class Pro extends Employee
{
Pro(String name,String id,double pay)
{
super(name,id,pay);
}
public void work()//实现work方法
{
System.out.println("Pro work:");
System.out.println("id:"+getId()+"\tname:"+getName()+"\tpay:"+getPay());
}
}
class Manager extends Employee
{
private int bonus;
Manager(String name,String id,double pay,int bonus)
{
super(name,id,pay);
this.bonus=bonus;
}
public int getBonus(){return bonus;}
public void work()//实现work方法
{
System.out.println("manager work:");
System.out.println("id:"+getId()+"\tname:"+getName()+"\tpay:"+getPay()+"\tbonus:"+getBonus());
}
}
class AbstractDemo
{
public static void main(String[] args)
{
Pro p=new Pro("张三","001",5000);
Manager m=new Manager("李四","002",6000,5000);
p.work();
m.work();
}
}
八、面向对象（模版方法模式）
什么是模版方法呢？
在定义功能时，功能的一部分是确定的，但是有一部分是不确定了。而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去，由该类的子类去完成，从而提高扩展性和复用性。
例子：
/*
需求：获取一段程序的运行时间。
原理：获取程序开始和结束的时间并进行相减。
获取时间：System.currentTimeMillis();
*/
abstract class GetTime
{
public final void getTime()//不可被子类覆盖
{
long start=System.currentTimeMillis();
runCode();//运行执行代码函数
long end=System.currentTimeMillis();
System.out.println("\n执行时间："+(end-start)+"毫秒");
}
public abstract void runCode();//抽象功能runCode
}
class SubTime extends GetTime
{
public void runCode()//实现功能runCode
{
for(int i=0;i<100;i++)
{
System.out.print(i);
}
}
}
class TemplateDemo
{
public static void main(String[] args)
{
SubTime gt=new SubTime();
gt.getTime();
}
}
九、面向对象（接口）
接口：
初期理解：可以认为是一个特殊的抽象类。当抽象类中的方法都是抽象的，
那么该类可以通过接口的形式来表示。
class：用于定义类
interface:用于定义接口
接口在定义时的格式特点：
1.接口中常见定义：常量，抽象方法。
2.接口中的成员都有固定修饰符：
常量：public static final
方法：public abstract
注意：接口中的成员都是public的。
接口是不可以创建对象的，因为有抽象方法，需要被子类去实现。子类对接口
中的抽象方法全都覆盖实现后，子类才可以实例化，否则子类是一个抽象类。
一个类可以实现多个接口，也是对多继承不支持的转换形式。
接口的特点：
1. 接口是对外暴露的规则。
2. 接口是程序的功能扩展。
3. 接口可以用来多实现。
4. 类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。
5. 接口与接口之间可以有继承关系。
/*
接口：
*/
interface Inter
{
public static final int NUM=3;
public abstract void show();
}
interface InterA
{
public abstract void method();
}
class Demo
{
public void function(){}
}
class Test extends Demo implements Inter,InterA
{
public void show(){}
public void method(){}
}
class InterfaceDemo
{
public static void main(String[] args)
{
Test t=new Test();
System.out.println(t.NUM);
System.out.println(Test.NUM);
System.out.println(Inter.NUM);
}
}
接口之间可以实现多继承，例如：
interface A
{
public abstract void showA();
}
interface B
{
public abstract void showB();
}
interface C extends B,A
{
public abstract void showC();
}
class D implements C
{
public void showA(){}
public void showB(){}
public void showC(){}
}
基本功能定义在类中，扩展功能定义在接口中
例如：
abstract class Student
{
abstract void study();
void sleep()
{
System.out.println("sleep");
}
}
interface Smoking
{
public abstract void smoke();
}
class ZhangSan extends Student implements Smoking
{
void study(){}
public void smoke(){}
}
abstract class Sporter{abstract void play();}interface Study{public abstract void study();}class WangWu extends Sporter implements Study{void play(){}public void study(){}}