前面内容请见:
JAVA基础–JAVA SE(知识点总结 Ⅰ )
JAVA基础–JAVA SE(知识点总结 Ⅱ )
JAVA基础–JAVA SE(知识点总结 Ⅲ )
JAVA基础–JAVA SE(知识点总结 Ⅳ )
以下是我们今天的内容:

本文目录:

  • 面向对象
    • 1.继承
    • 2.final关键字
    • 3.多态
    • 4.抽象类
    • 5.接口

面向对象

1.继承

  • 将多个类的共性内容抽取出来,放在一个独立的类中,让这个独立的类和其他类产生一种关系

    • “继承” ----> 关键字 extends

  • 格式

            class 父类名{共性内容:姓名,年龄.....提供公共的访问方法setXXX()/getXXX()}class 子类名 extends 父类名{}

  • 优点

    •          可以提高代码复用性

    •          可以提高代码的维护性,后期便于维护,针对子类和父类进行维护(子父关系明确)

    •          类与类产生的继承关系,是"多态"的前提条件

    •          在Java中有一个开发原则 "低耦合,高内聚"(Java设计模式都需要遵循这一个原则)*              耦合性:开发中是永远避免不了,可以降低(耦合:类和类的关系)*              内聚性:指的是某个类完成某个功能的一种能力; 尽量不要产生继承关系来完成一个功能,尽量一个类能完成一个类完成;*              低耦合:降低耦合性,减少类和类的关系;

  • 特点

    • 在Java语言中,类和的类的关系是一种继承关系,这个继承只能支持"单继承",不支持多继承

    •     class 父{}class 父2{}class 子 extends 父,父2{} //多继承:不支持        错class 子 extends 父{}    //正常的语法格式       对

    • 类和类关系,虽然不支持多继承,但是层层单继承----> 多层继承

      //定义父类
class GrandFather{public void method(){System.out.println("我是爷爷");}
}
//定义父类
class Father extends  GrandFather{public void show(){System.out.println("我是父亲");}
}
//父类
//class Mother{}
//子类
//class Son extends  Father,Mother{} //子类不能继承多个父类,多继承语法不支持
class Son extends  Father{//自己的特有功能public void playGame(){System.out.println("会玩游戏");}
}
public class ExtendsDemo {public static void main(String[] args) {//创建Son类对象Son s = new Son() ;s.show();  //访问父亲的方法s.method();//访问爷爷的方法(method方法间接继承过来)s.playGame(); //访问自己的方法}

注意:

  •  子类继承父类,对于非私有的成员,直接可以继承过来,但是如果是私有成员,它可以通过公共的访问去访问,但不是直接访问的

  •  被私有修饰的东西(成员变量/成员方法),只能在当前类访问的

  • 在继承关系中,构造方法的访问问题(重点):

    • 子类继承父类,子类的所有构造方法都默认访问父类的无参构造方法

    • 为什么?

      •  子类继承父类,会用到父类的数据,需要让父类先进行初始化;   一个类初始化的---肯定需要执行构造方法的

    • 如果一个父类存在有参构造方法,没有无参构造方法,子类的所有构造会出现什么问题?出现了问题,怎么解决?

      • 子类的所有全部构造方法报错,子类继承父类,子类的所有构造方法都默认访问父类的无参构造方法

      • 解决方案1:

        • 手动给出无参构造方法

              public 类名（）{}

      • 解决方案2:

        •  假设,人家现在就不需要让你给出父类的无参构造方法,就需要让子类的构造方法,显示的访问父类的有参构造方法 *      要使用关键字 <strong>super</strong>:代表父类空间标识(代表的父类对象的地址值引用)*      super() :访问父类的无参构造方法*      super(xxx) :访问父类的有参构造方法*      这些super一定是在子类构造方法中的第一句话

      • 解决方案3:

        •  保证子类的所有的构造方法某一个构造方法,让父类初始化完毕即可;

        •  先通过子类的无参构造方法里面---this(xxx):访问本类(子类)有参构造方法

        •  再子类的有参构造方法的第一话:让父类初始化 super(xxx):间接访问父类的有参构造方法

        •  子类继承父类,一定要先执行父类的构造方法,初始化完毕之后;然后才能执行子类的构造方法---分层初始化

注意: 子类在隐藏了一个super(),所以先要访问父类构造方法,在执行子类,如果有super(xxx),则super()不自动创建

  • 子类继承父类,成员变量的访问问题:

    • 情况1: 子类和父类的中成员变量名称不一致,访问时,只要分别访问即可
    • 情况2: 子类和父类的成员变量名称一致,访问时:
      • 先在子类的局部位置找,有没有这个变量,如果有就使用
      • 要是没有,在子类成员位置中继续找,有没有这个变量,如果有就使用
      • 要是子类的成员位置也没有,那么会在父类的成员位置继续找,看有没有这个变量,有的话就使用
      • 如果父类的成员位置同样还没有的话,则会报错(前提:这个父类没有它的父类了),说明整个子父类中都没有变量
      • 遵循"就近原则"

如果是向上转型的时候,父类名 对象名 = new 子类名; ---- > 成员变量输出为父类的值

//父类
class Person{int age = 20;
}
//子类class Man extends Person{int age = 40;
}
public class Test{public static void main(String[] args){Person person = new Man();System.out.println(person.age); //20}
}

想要输出子类成员变量值需要用到向下转型(具体后面会分析)

  • 子类继承父类,关于成员方法的访问:

    • 情况1:子类和父类的成员方法名称不一致,调用时,只要分别调用就可以

    • 情况2:子类和父类的成员方法一模一样时(权限修饰符,返回值类型,参数列表都一样)

      • 子类将父类的方法覆盖了---->方法重写 :Override---->子类在父类的基础上,将父类的覆盖了,使用自己的功能;
      public class Person {//确定属性private String name;private int age;private String professional;//无参public Person() {}//有参public Person(String name, int age, String professional) {this.name = name;this.age = age;this.professional = professional;}......//定义方法public void eat(){System.out.println("都喜欢吃");}public void show(){System.out.println("姓名:" + name + "\n" + "年龄:" + age + "\n" + "职业:" + professional);}
}
//子类
public class SourthPerson extends Person{public SourthPerson() {}......@Override //重写public void eat() {System.out.println("南方人喜欢吃大白米饭");}
}
//测试类
public class PersonTest {public static void main(String[] args) {//无参--南方SourthPerson sourthPerson = new SourthPerson();sourthPerson.setName("张三");sourthPerson.setAge(33);sourthPerson.setProfessional("商人");sourthPerson.show();sourthPerson.eat();sourthPerson.favorite();}
}

补充:

类加载的时候,内存是很快的(继承关系)