面向对象（二）

---------------------- QQ:371524846 期待与您交流！ ----------------------

一、继承

　　继承是面向对象三大特征之一，也是实现软件复用的重要手段。

　　1、继承概述：

　　　　子类会自动继承父类所有方法和属性，称为继承。
　　　　父类是从子类不断往上抽取出来的。

　　2、继承的作用：

　　　　提高了代码的复用性。
　　　　让类与类之间产生了关系。有了这个关系，才有了多态的特性。

　　注意：千万不要为了获取其他类的功能，简化代码而继承。
　　　　必须是类与类之间有所属关系才可以继承。所属关系is a。

　　Java语言中：java只支持单继承，不支持多继承。

　　3、继承的缺点：

　　　　因为多继承容易带来安全隐患：当多个父类中定义了相同功能，
　　　　当功能内容不同时，子类对象不确定要运行哪一个。也就是说多继承的缺点即是引发二义性。

　　　　但是Java保留这种机制。并用另一种体现形式来完成--------多实现。
　　　　Java支持多层继承，也就是一个继承体系。

　　　　如何使用一个继承体系中的功能呢？
　　　　想要使用体系，先查阅体系中父类的描述，因为父类中定义的是该体系中共性功能。
　　　　通过了解共性功能，就可以知道该体系的基本功能。
　　　　那么这个体系已经可以基本使用了。
　　　　那么在具体调用时，要创建最子类的对象，为什么呢？
　　　　　　一是因为有可能父类不能创建对象；
　　　　　　二是创建子类对象可以使用更多的功能，包括基本的也包括特有的。

　　注意：
　　　　构造函数是继承不了的。
　　　　Private的属性和方法也是无法继承的。

　　　　简单一句话：查阅父类功能，创建子类对象使用功能。

eg:

class C{
    demo1(){}  //所提取到的共性的方法
}
class A extends C{
    //demo1(){}
    demo2(){}
}
class B extends C{
    //demo1(){}
    demo2(){}
}

　　4、子父类出现后，类成员的特点：
　　　　4.1 类中成员：
　　　　　　变量。
　　　　　　函数。
　　　　　　构造函数。
　　　　　　构造代码块
　　变量：
　　　　如果子类中出现非私有的同名成员变量时，
　　　　子类要访问本类中的变量，用this。
　　　　子类要访问父类中的同名变量，用super。

　　　　super的使用和this的使用几乎一致。
　　　　this代表的是本类对象的引用。
　　　　super代表的是父类对象的引用。
eg:

class Fu{
    int num = 4;
}
class Zi extends Fu{
    int num = 5; 
    void show(){
        System.out.println(num);//this引用，此处省略this，结果是5 
        System.out.println(super.num); //super引用，结果是3.
    }
}
public class ExtendsLearn
{
    public static void main(String[] args){
        Zi z = new Zi();
        z.show();
    }
}

　　5、子父类中的函数

　　　　5.1覆盖（重写）

　　　　什么情况下用到覆盖呢？

　　　　　当子类继承父类，沿袭了父类的功能，到子类中，
　　　　  但是子类虽具备该功能，但是功能的内容却和父类不一致，
　　　　  这时，没有必要定义新功能，而是使用覆盖特性，保留父类的功能定义，并重写功能内容。

　　覆盖（注意事项）：
　　(1)子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则，编译失败。
　　(2)静态只能覆盖静态。(若出现这种情况就和多态没关系了，编译器直接做选择了)

eg:

class Fu {
    public int field = 10;
    public void fun() {
        System.out.println("Hello A");
    }
    public static void sFun() {
        System.out.println("hello A");
    }
}
class Zi extends Fu {
    public int field = 20;   //重写父类属性
    //重写父类函数
    public void fun() {     
        System.out.println("Hello B");
    }
    public static void sFun() {   //重写父类函数
        System.out.println("hello B");
    }
}
public class MainApp {
    public static void main(String[] args) {
        Fu f1 = new Zi();
        f1.fun();    // Hello B
        f1.sFun();  // Hello A
        System.out.println(f1.field);   // 10
    }
}

　　在内存中的加载方式：　

　　　　5.2 子父类中的构造函数:

　　　　　　在对子类对象进行初始化时，父类的构造函数也会运行，
　　　　　　 那是因为子类的构造函数默认第一行有一条隐式的语句super();
　　　　　　super():会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super();
　　注意：
　　　　a.如果父类中无空参数构造函数（即父类中显式的构造了含有参数的构造函数），必须手动加入父类中该构造函数。
　　　　b.构造函数不存在覆盖，子类中的构造函数必定至少有一个会访问父类中的构造函数。

eg:

class Fu {
    Fu(){}
}
class Zi extends Fu {
    Zi(){
    super(); //不带参数,可以隐藏,不用手动添加super()
    }
}
------------------------------------------------------------------
class Fu {
    Fu(int x){}
}
class Zi extends Fu {
    Zi(){
    super(x); //必须手动添加super(x),因为带参数。
    }
}

　　　　总结：子类实例化过程
　　　　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:

abstract class Person   
{  
    private String name;  
    public Person(String name)  
    {  
        this.name = name;  
    }  
    //抽象方法：对人的描述，但对每种人的描述是不清楚的，所以用抽象方法  
    public abstract String getInform();  
  
    public String getName()  
    {  
        return name;  
    }  
}  
//Student继承父类Person  
class Student extends Person  
{  
    public Student(String name)  
    {  
        super(name);  
    }  
    //重写父类的抽象方法，对学生进行具体描述  
    public String getInform()  
    {  
        return "I'm a student.";  
    }  
}  
//Teacher继承父类Person  
class Teacher extends Person  
{  
    public Teacher(String name)  
    {  
        super(name);  
    }  
    //重写父类的抽象方法，对老师进行具体描述  
    public String getInform()  
    {  
        return "I'm a Teacher.";  
    }  
}  
//测试  
public class PersonTest  
{  
    public static void main(String[] args)   
    {  
        Person[] p = new Person[2];//用抽象类创建数组  
        //再创建两个对象存入数组  
        p[0] = new Student("Nan");  
        p[1] = new Teacher("Wan");  
        System.out.println(p[0].getName() + ":" + p[0].getInform());  
        System.out.println(p[1].getName() + ":" + p[1].getInform());  
    }  
}
    在这里，Person[] p = new Person[2]只是创建了两个数组类型的元素，并不是Person类对象，
    在这里只是一种引用。而下面的new Student和new Teacher才真正创建了两个对象，分别赋值给
    数组中的两个元素，或者说是两个变量。

　　3、抽象类和一般类没有太大的不同：
　　　　　 该如何描述事物，就如何描述事物，只不过，该事物出现了一些看不懂的东西。这些不确定的部分，也是该事物的功能，

　　　　　需要明确出现，但是无法定义主体。通过抽象方法来表示。
　　　　a)抽象类比一般类多了个抽象函数。
　　　　b)抽象类不可以实例化。
　　特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。

---------------------- QQ:371524846 期待与您交流！ ----------------------