---------------------- QQ:371524846 期待与您交流！ ----------------------
一、继承
继承是面向对象三大特征之一，也是实现软件复用的重要手段。
1、继承概述：
子类会自动继承父类所有方法和属性，称为继承。
父类是从子类不断往上抽取出来的。
2、继承的作用：
提高了代码的复用性。
让类与类之间产生了关系。有了这个关系，才有了多态的特性。
注意：千万不要为了获取其他类的功能，简化代码而继承。
必须是类与类之间有所属关系才可以继承。所属关系is a。
Java语言中：java只支持单继承，不支持多继承。
3、继承的缺点：
因为多继承容易带来安全隐患：当多个父类中定义了相同功能，
当功能内容不同时，子类对象不确定要运行哪一个。也就是说多继承的缺点即是引发二义性。
但是Java保留这种机制。并用另一种体现形式来完成--------多实现。
Java支持多层继承，也就是一个继承体系。
如何使用一个继承体系中的功能呢？
想要使用体系，先查阅体系中父类的描述，因为父类中定义的是该体系中共性功能。
通过了解共性功能，就可以知道该体系的基本功能。
那么这个体系已经可以基本使用了。
那么在具体调用时，要创建最子类的对象，为什么呢？
一是因为有可能父类不能创建对象；
二是创建子类对象可以使用更多的功能，包括基本的也包括特有的。
注意：
构造函数是继承不了的。
Private的属性和方法也是无法继承的。
简单一句话：查阅父类功能，创建子类对象使用功能。
eg:
1 class C{ 2 demo1(){} //所提取到的共性的方法 3 } 4 class A extends C{ 5 //demo1(){} 6 demo2(){} 7 } 8 class B extends C{ 9 //demo1(){} 10 demo2(){} 11 }
4、子父类出现后，类成员的特点：
4.1 类中成员：
变量。
函数。
构造函数。
构造代码块
变量：
如果子类中出现非私有的同名成员变量时，
子类要访问本类中的变量，用this。
子类要访问父类中的同名变量，用super。
super的使用和this的使用几乎一致。
this代表的是本类对象的引用。
super代表的是父类对象的引用。
eg:
1 class Fu{ 2 int num = 4; 3 } 4 class Zi extends Fu{ 5 int num = 5; 6 void show(){ 7 System.out.println(num);//this引用，此处省略this，结果是5 8 System.out.println(super.num); //super引用，结果是3. 9 } 10 } 11 public class ExtendsLearn 12 { 13 public static void main(String[] args){ 14 Zi z = new Zi(); 15 z.show(); 16 } 17 }
5、子父类中的函数
5.1覆盖（重写）
什么情况下用到覆盖呢？
当子类继承父类，沿袭了父类的功能，到子类中，
但是子类虽具备该功能，但是功能的内容却和父类不一致，
这时，没有必要定义新功能，而是使用覆盖特性，保留父类的功能定义，并重写功能内容。
覆盖（注意事项）：
(1)子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则，编译失败。
(2)静态只能覆盖静态。(若出现这种情况就和多态没关系了，编译器直接做选择了)
eg:
1 class Fu { 2 public int field = 10; 3 public void fun() { 4 System.out.println("Hello A"); 5 } 6 public static void sFun() { 7 System.out.println("hello A"); 8 } 9 } 10 class Zi extends Fu { 11 public int field = 20; //重写父类属性 12 //重写父类函数 13 public void fun() { 14 System.out.println("Hello B"); 15 } 16 public static void sFun() { //重写父类函数 17 System.out.println("hello B"); 18 } 19 } 20 public class MainApp { 21 public static void main(String[] args) { 22 Fu f1 = new Zi(); 23 f1.fun(); // Hello B 24 f1.sFun(); // Hello A 25 System.out.println(f1.field); // 10 26 } 27 }
在内存中的加载方式：
5.2 子父类中的构造函数:
在对子类对象进行初始化时，父类的构造函数也会运行，
那是因为子类的构造函数默认第一行有一条隐式的语句super();
super():会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super();
注意：
a.如果父类中无空参数构造函数（即父类中显式的构造了含有参数的构造函数），必须手动加入父类中该构造函数。
b.构造函数不存在覆盖，子类中的构造函数必定至少有一个会访问父类中的构造函数。
eg:
1 class Fu { 2 Fu(){} 3 } 4 class Zi extends Fu { 5 Zi(){ 6 super(); //不带参数,可以隐藏,不用手动添加super() 7 } 8 } 9 ------------------------------------------------------------------ 10 class Fu { 11 Fu(int x){} 12 } 13 class Zi extends Fu { 14 Zi(){ 15 super(x); //必须手动添加super(x),因为带参数。 16 } 17 }
总结：子类实例化过程
a. 子类所有的构造函数默认均访问父类中的空参数构造函数，因为子类每个构造函数内的第一行均有一句隐式的super();语句。
b. 当父类中悟空参数构造函数时，子类必须手动通过super语句的形式指定要访问的父类中的构造函数
c. 子类构造函数也可手动指定this语句，来访问本类中的构造函数，但子类中至少要有一个构造函数访问父类的构造函数。
6、final修饰符
（1）可以修饰类、函数、变量。
（2）被final修饰的类不可以被继承，为了避免被继承，被子类复写功能。
（3）被final修饰的方法不可以被复写。
（4）被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，有可能修饰局部变量。当在描述事物时，
一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字，方便阅读。而这个值不需要改变，所以加上final修饰。
作为常量：常量的书写规范所有字母都大写，如果由多个单词组成，单词见通过_链接。
（5）内部类定义在类中的局部位置上是，只能访问该局部被final修饰的局部变量。
二、抽象类
1、抽象类的含义：
当多个类中出现相同功能，但是功能主体不同，这时可以进行向上抽取，这时只抽取功能定义，而不抽取功能主体。
2、抽象类的特点：
(1)抽象方法一定在抽象类中。
(2)抽象方法和抽象类都必须被abstract关键字修饰。
(3)抽象类不可以用new创建对象。因为调用抽象方法没意义。
(4)抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。
如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。
eg:
1 abstract class Person 2 { 3 private String name; 4 public Person(String name) 5 { 6 this.name = name; 7 } 8 //抽象方法：对人的描述，但对每种人的描述是不清楚的，所以用抽象方法 9 public abstract String getInform(); 10 11 public String getName() 12 { 13 return name; 14 } 15 } 16 //Student继承父类Person 17 class Student extends Person 18 { 19 public Student(String name) 20 { 21 super(name); 22 } 23 //重写父类的抽象方法，对学生进行具体描述 24 public String getInform() 25 { 26 return "I'm a student."; 27 } 28 } 29 //Teacher继承父类Person 30 class Teacher extends Person 31 { 32 public Teacher(String name) 33 { 34 super(name); 35 } 36 //重写父类的抽象方法，对老师进行具体描述 37 public String getInform() 38 { 39 return "I'm a Teacher."; 40 } 41 } 42 //测试 43 public class PersonTest 44 { 45 public static void main(String[] args) 46 { 47 Person[] p = new Person[2];//用抽象类创建数组 48 //再创建两个对象存入数组 49 p[0] = new Student("Nan"); 50 p[1] = new Teacher("Wan"); 51 System.out.println(p[0].getName() + ":" + p[0].getInform()); 52 System.out.println(p[1].getName() + ":" + p[1].getInform()); 53 } 54 } 55 在这里，Person[] p = new Person[2]只是创建了两个数组类型的元素，并不是Person类对象， 56 在这里只是一种引用。而下面的new Student和new Teacher才真正创建了两个对象，分别赋值给 57 数组中的两个元素，或者说是两个变量。
3、抽象类和一般类没有太大的不同：
该如何描述事物，就如何描述事物，只不过，该事物出现了一些看不懂的东西。这些不确定的部分，也是该事物的功能，
需要明确出现，但是无法定义主体。通过抽象方法来表示。
a)抽象类比一般类多了个抽象函数。
b)抽象类不可以实例化。
特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。
---------------------- QQ:371524846 期待与您交流！ ----------------------