继承、重载、重写、多态、抽象类

一、继承

        继承是一种严格的父子关系（在父类里面抽取的属性和方法一定是所有子类所共有）。

        面向对象特征：抽象、封装、继承、多态

        Java是单继承，就是一个类只能继承extends(inherit)一个类，而java中面向对象的语言就是对现实

        Object是所有类的父类（这个父类不一定是直接父类）

public class Person /*extends Object*/ {
    //private只在类的内部访问，子类也不行
    //public公开也不行
    //protected可以
    protected int id;
    protected String name;
    protected int age;
    
     public Person() {
        //Java里面new子类对象时候首先new父类对象
        super();//new Object无参构造方法
    }

    //assign:赋值 access:访问
    public Person(int id, String name, int age) {
        //Java里面new子类对象时候首先new父类对象
        super();//new Object无参构造方法
        this.id = id;
        this.name = name;
        this.age = age;
    }


    public void show() {
        System.out.println("person.show");
    }
}

        private:只在当前类里面可以访问（子类也不能访问）

        public：任何地方都可以访问

        protected：子类可以访问

	类内部	本包	子类	外部包
public	可以	可以	可以	可以
protected	可以	可以	可以	不可以
default	可以	可以	不可以	不可以
private	可以	不可以	不可以	不可以

        1、无参构造方法

        2、一个类不继承任何一个类默认继承extends Object

        3、在类的构造方法第一句默认会加上super()

this:代表当前类的对象 this.id=id

super：代表父类对象

this():调用当前类的无参构造方法

super():调用父类无参构造方法 

二、重载

        方法的重载： overload

        方法重载（Method Overloading）是指在同一个类中可以定义多个方法，它们具有相同的方法名但具有不同的参数列表。通过方法重载，可以使用相同的方法名来执行类似的操作，但根据传递给方法的参数的不同来调用不同的方法。

        在Java中，方法重载的规则如下：

• 1. 方法名相同。
  2. 参数列表必须不同，可以是参数的个数不同、参数类型不同或参数顺序不同。
  3. 返回类型可以相同也可以不同。
  4. 方法重载不依赖于方法的返回类型，只依赖于方法名和参数列表。

        重载：同一个类中方法名一样，参数列表不一样

        方法重载特点：与返回值无关，只看参数列表

        举例：

        void show(int a, char b, double c){}

        1、void show(int x, char y, double z){} 不是重载，是同一个方法

        2、int show(int a, double c, char b){} 是重载，参数顺序不一样和返回值无关

        3、void show(int a, double c, char b){} 是重载，参数顺序不一样

        4、boolean show(int c, char b){} 是重载

        5、void show(double c){ } 是重载

        6、double show(int x, char y, double z){} 不是重载

三、重写

        重写（覆盖）@Override：toString()

        1、子类覆盖父类，必须保证子类权限大于父类权限才可以覆盖，否则会编译失败。

        2、如果父类是private的方法，子类是默认方法，那么子类是不知道这个方法的，不是覆盖。

        重载（Overload）：同一个类中看同名方法的参数列表（构造方法重载）

        重写（Override）：父子类方法要一模一样

四、多态

        多态存在的三个必要条件：

• 1. 继承
  2. 重写
  3. 父类引用指向子类对象：Parent p = new Child();

 

@Test
public void test1() {
    //声明成子类类型，new子类对象
    Add add = new Add(3, 2);
    //如果子类重写了getResult方法，那么调用的就是重写后的方法
    //如果子类没有重写，调用的是从父类继承的
    int result = add.getResult();
    System.out.println(result);

    //声明成父类类型，new子类对象
    /*
    Cal cal;
    cal = new Add(3,2)
     */
    Cal cal = new Add(3, 2);
    //Person person = new Student();
    //person = new Teacher();
    int result2 = cal.getResult();
    System.out.println(result2);

    cal = new Sub(3, 2);
    int result3 = cal.getResult();
    System.out.println(result3);
}

五、抽象类

        1、抽象方法是没有方法体，如果这个类里面有抽象方法，这个类必须变成抽象类。

        2、如果这个类是抽象类，并不要求这个类一定要有抽象方法

        3、抽象类里面可以有普通方法，也可以有抽象方法。

        4、如果一个类是抽象类，那么这个类就不能被new实例化，只能被其他类继承。

        5、抽象方法可以理解为父类（抽象类）定义的一个模板或者规范（自己本身不实现），

子类必须实现这个抽象方法，如果子类不想实现这个方法，那么这个子类也必须要变成抽象类。

public abstract class Cal {
    protected int num1;
    protected int num2;

    //抽象方法：没有方法体，如果这个类里面有抽象方法，这个类必须变成抽象类
    public abstract int getResult();
}