面向对象（继承与抽象）

继承：

   继承的好处：提高了代码的复用性，让类与类之间产生了关系，将对象中的共性内容不断的向上抽取，就形成了关系，然后就有了继承，有了子类父类，提高了代码的复用。

  继承的特点：1、java中只能单继承，单继承是一个类只能有一个父类。但是java不能支持多继承是因为会产生调用的不确定性，但是java支持多层继承。

  如何使用一个继承体系中的成员呢？1、查阅该顶中的顶层类的内容，因为通过该类可以了解该体系的基本功能。2、创建最子类的对象，即可以调用共性的基本内容，也可以使用子类的特有功能。简单说：看父类内容，建立子类对象使用。

  关于什么时候定义继承？必须是事物之间存在着所属关系的时候才能定义继承。误区：不要仅仅为了提高复用，为了方便获取其他类中的内容而去继承。

  继承中成员的特点：1、成员变量2、成员函数3、构造函数。super代表父类用法和this相似，this代表对本类对象的引用，super代表父类所属空间。注意：子父类中通常不会出现同名的属性。子类只能直接继承父类中的非私有属性。

   继承中成员函数的特点：当子父类中出现一模一样的方法的时候，会发生一个函数的特性：覆盖（override）

    

package com_package1;

public class Fu {
    void show()
    {
        System.out.println("fu run");
    }

}

package com_package1;

public class Zi extends Fu {
     void show()
     {
         System.out.println("zi run");
         
     }
}

package com_package1;

public class ExtendsDemo {
    public static void main(String[]args)
    {
        Zi z = new Zi();
        z.show();
        
    }

}

zi run//子类中有这个方法何必去父类中寻找

父类中：子父类中通常不会出现同名的属性。父类中既然定义了某个属性，那么子类其实就没有必要在定义该属性了。

继承中成员函数的特点：

    当子父类中出现一模一样的方法的时候，会发生一个函数的特性：覆盖。覆盖注意事项：1、子类覆盖父类的时候，必须要保证方法的权限大于等于被覆盖的方法的权限。2、覆盖方法有静态修饰时，静态只能覆盖静态，或者被静态覆盖。

     继承了父类中的功能后，想要对已有的功能进行内容的改变，意味着功能的声明不变，将内容在子类中进行自定义，这种定义就是覆盖

    

package com_package1;

public class Phone {
    void show()
    {
       System.out.println("number");    
    }

}

package com_package1;

import javax.sound.midi.SysexMessage;

public class NewPhone extends Phone {
    void show()
    {
        
        //System.out.println("name");
        super.show();
        System.out.println("name");
    }
     
    

}

package com_package1;

public class NewPhoneDemo {
    public static void main(String[]args)
    {
        NewPhone np = new NewPhone();
        np.show();
        
    }

}

number
name

继承中的构造函数：

   子类实例化过程：其实在子类的所有构造函数中的第一行默认有一条隐式语句就是super（），也就是说子类的构造函数默认都会访问父类中空参数的构造函数。

    为什么子类的构造函数都要去访问父类额构造函数呢？因为子类继承了父类，可以访问父类中已有的属性，在子类进行实例化的时候必须要为费中的属性分配空间，并要进行初始化，所以必须要访问一次父类的构造函数，看看父类是如何堆属性进行初始化 额，所以子类要实例化对象的时候必须要先看父类的初始化过程。

  结论：父类的构造函数，既可以给本类进行初始化，又可以给子类对象初始化

package com_package1;

public class Phone {
    void show()
    {
       System.out.println("number");    
    }

}

package com_package1;

public class NewPhone extends Phone {
    void show()
    {   
        //super();

        //System.out.println("name");
        super.show();
        System.out.println("name");
    }
     
    

}

    

注意，如果父类中没有空参数的构造函数，子类的构造函数中必须手动用super来指定要访问的父类中的构造函数。

比如：

package com_package1;

public class Fu1 {
    //Fu1()
    //{
    //    System.out.println("fu kong");
    //}
    Fu1(int x)
    {
        
        System.out.println("x"+x);
    }

}

package com_package1;

public class Zi1 extends Fu1 {
    Zi1()
    {
        super(3);
        System.out.println("Zi kong");
    }
    Zi1(int x)
    {
        super(6);
        System.out.println(x);
    }

}

package com_package1;

public class Zi1Demo {
    public static void main(String[]args)
    {
        Zi1  z = new Zi1(6);
        System.out.println(z);
        
    }

}

x6
6
com_package1.Zi1@1fc4bec

注意：如果父类中没有空参数的构造函数，子类的构造函数中必须手动用super来指定要访问的父类中的构造函数，或者用this来指定访问的本类中的构造函数，this 和super调用构造函数只能定义构造函数的第一行，不能同时出现。

  关于子类继承父类的某些属性以及改写某些属性的方法：

package com_package1;

public class Person1 {
    private String name;
    private int age;
    Person1(String name,int age)
    {
        this.name =name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    

}

package com_package1;

public class Student1 extends Person1{

    Student1(String name, int age) {
        super(name, age);
        // TODO Auto-generated constructor stub
    }

}

package com_package1;

public class Student1Demo {
    
    public static void main(String[]args)
    {
        Student1 st = new Student1("kaka", 23);
        System.out.println(st.getName());
        System.out.println(st.getAge());
        
    }

}