继承

继承是三大面向对象特征之一，继承无处不在，继承不仅是代码复用，精髓之处在于用抽象思维编写代码，以达到程序更强的可扩展性。

//继承一个父类，只能继承非私有的数据（属性和方法）
//protected访问权限修饰符，在继承关系中使用。在父类中使用protected修饰的属性或方法可以被子类继承
//创建子类对象，父类对象的构造方法也会被调用：因为子类要用到父类的数据，那么就要通过父类的构造方法来初始化数据
//如果创建子类对象时使用默认的构造方法，那么父类默认构造方法也会被调用
//如果创建子类对象时使用的是带参数的构造，也会调用父类默认构造方法

//当父类中没有无参构造方法时，子类必须显示的调用父类的带参构造方法
//可以再子类中显示的使用super(...)调用父类的否早方法，只能出现在第一句
public class test {
    public static void main(String[] args) {
        HomeDog homedog = new HomeDog("旺财");
        homedog.print();
        homedog.eat(); //复用
    }
}

class Dog{
    protected String name; //protected访问权限修饰符，在继承关系中使用
    private String sex;
//    public Dog() {
//        System.out.println("我是DOG的构造方法");
//    }
    public Dog(String name ,String sex){
        this.name = name;
        this.sex = sex;
        System.out.println("我是DOG的构造方法");
    }
    public void eat(){
        System.out.println("吃饭");
    }
}
class HomeDog extends Dog{

    public HomeDog(String name) {
//        this.name = name;
        super(name,"公");
        System.out.println("我是HOMEDOG的构造方法");
    }
    public void print() {
        System.out.println(name+"我是一只家狗");
    }

}

class HuskyDog extends Dog{
    public HuskyDog() {
        super("hashiqi","母");
        System.out.println("我是HUSKYDOG的构造方法");
    }
    public void show() {
        System.out.println(name+"我是husky");
    }
}

方法重写：

public class test {
    public static void main(String[] args) {
        HomeDog homedog = new HomeDog("旺财");
        homedog.print();
        homedog.eat(); //复用
    }
}

class Dog{
    protected String name; //protected访问权限修饰符，在继承关系中使用
    private String sex;
//    public Dog() {
//        System.out.println("我是DOG的构造方法");
//    }
    public Dog(String name ,String sex){
        this.name = name;
        this.sex = sex;
        System.out.println("我是DOG的构造方法");
    }
    public void eat(){
        System.out.println("吃饭");
    }
}
class HomeDog extends Dog{

    public HomeDog(String name) {
//        this.name = name;
        super(name,"公");
        System.out.println("我是HOMEDOG的构造方法");
    }
    public void print() {
        System.out.println(name+"我是一只家狗");
    }

    public void eat(){
        System.out.println("我要吃饭饭wahuhuhu"); //方法重用
    }

}

class HuskyDog extends Dog{
    public HuskyDog() {
        super("hashiqi","母");
        System.out.println("我是HUSKYDOG的构造方法");
    }
    public void show() {
        System.out.println(name+"我是husky");
    }
    public void eat(){
        System.out.println("我喜欢吃鸡肝"); //方法重用，重写父类的方法
    }
}

overloading（方法重载）与overridding（方法重写）的区别？

overloading：方法的重载，发生在同一个类中，方法名相同，参数列表不同，返回值无关。

overridding：方法的重写，发生在子父类中，方法名相同，参数列表相同，返回值相同，子类的访问修饰符要大于或等于父类的访问修饰符，子类的异常声明必须小于或等于父类的异常声明，如果方法被private，static，final修饰，那么不能被重写。

重写与重载的区别，切记方法的重写是发生在子父类继承关系中，不同于方法重载发生在同一个类。

super关键字

继承的应用思考题：

比较两个字符串相等，不能使用==，使用eauals()

final关键字（相当于const）

final关键字，声明的属性值不能改，声明的方法不能被子类重写，声明的类无法被继承（扩展）。

/**
 * final关键字
 * 1.使用final声明一个属性，就是常量，常量的命名规则建议使用全大写，常量必须在定义时或在构造时进行初始化
 * 2.使用final声明的方法，不能被子类重写，只能被继承，“最终方法的意思”
 * 3.使用final声明一个类，该类就转变为最终类，没有子类，无法被继承
 * 4.作为方法中的参数，方法中不可改变
 */
public class test {
    //private static final int PERSON_NUM = 10; //常量不能修改，与对象无关，所以通常加上static
    public static void main(String[] args) {
        System.out.println(Constant.PERSON_NUM);

    }
}

//常量类（工具类，使得其他类都能调用
//在实际项目开发中，常用于定义项目一些公共的，不变的数据
class Constant {
    public static final int PERSON_NUM = 10; //人数
}

final class Constant1{
    public static final int HH=100;
}

//无法从final继承
//class Constant2 extends Constant1{
//
//}

class FinalClass {
    public final int DAY_NUMBER; //工作天数

    public FinalClass() {
        DAY_NUMBER = 22;
    }

    public final void print(){
        System.out.println("我是final方法");
    }

    public void SetLength(final int size) {
//        size++;
//        无法赋值给size
    }
}

class SunClass extends FinalClass{
//test.SunClass中的print()无法覆盖test.FinalClass中的print()
//    public void print(){
//        System.out.println("我是final1方法");
//    }
}

抽象类：

很多对象可以抽象出一个类，很多类可以抽象出抽象类

接口：

接口是所有行为的抽象，面向接口编程，目的是让程序更加易于维护，扩展性更强，接口只定义标准，而非具体实现。 接口之间可以多继承（注意类只能单继承），实现接口的类也可以多继承。

接口中定义的方法没有声明修饰符，默认为public abstract

多态性：

多态是抽象编程的精髓所在，用抽象的思维写代码，在运行过程中再传入具体的对象，同面向接口编程如出一辙。

如下图所示，编译期将会检查chicken类的方法，是否有eat，song；若传入chicken的子类，子类中虽然有这俩个方法，但chicken类中没有，就会报错，因为编译期就已经出现了问题。所以程序要考虑编译期和运行时两方面的错误。

若想用子类jianjiaochicken的方法，在eat方法中需要进行强制转换，以达到使用song的方法。

instead of关键字

对象本身以及对象的父类型，都可以通过检查。

抽象类应用——模板方法模式

其精髓之处在于定义一个算法框架，也就是把共有部分抽象出来，这是对未来底层框架设计非常有用。

拓展：

单继承、多继承、虚继承_sophia__yu的博客-CDN博客_单继承和多继承的区别https://blog.csdn.net/sophia__yu/article/details/82791522?ops_request_misc=&request_id=&biz_id=102&utm_term=%E5%8D%95%E7%BB%A7%E6%89%BF%E5%92%8C%E5%A4%9A%E7%BB%A7%E6%89%BF%E7%9A%84%E5%8C%BA%E5%88%AB&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-0-82791522.142%5Ev70%5Ejs_top,201%5Ev4%5Eadd_ask&spm=1018.2226.3001.4187