继承

继承 :  子承父业
        目的 : 提高代码的复用性
        作用: 子类一旦继承父类,有权使用父类中的成员,可以在子类中定义子类独有的内容
        定义:   子类  extends  父类

    实体类|子类 : 根据一系列对象抽取共性所定义的实体类
    父类 : 子类的共性

    子类| 派生类
    父类 | 基类 | 超类

    特点 : 单继承机制 ,一个子类只能继承一个父类,但是一个父类可以存在多个子类
          修饰类只能使用public|default(默认)
          开闭原则--> 面试对象设计原则之一  : 对修改关闭,对扩展开放

    单继承的优点 : 简单
    单继承的缺点 : 不便于后期维护

    练习 : 定义猫,狗类,分析通过继承结果实现

例子

public class Class001_Extends {
    public static void main(String[] args) {
        Teacher t = new Teacher();
        t.name = "马云";
        t.age = 50;
        t.subject = "英语";
        t.teach();
        t.sleep();
    }
}

//父类
class Person{
    public String name;
    public int age;

    public void sleep(){
        System.out.println(name+"在休息");
    }
}

//子类
class Teacher extends Person{
    public String subject;  //教授学科

    //构造器
    public Teacher(){

    }
    public void teach(){
        System.out.println("教书育人!!!");
    }
}
//子类
class Student extends Person{
    public int num;  //学号

    //构造器
    public Student(){

    }

    public void study(){
        System.out.println("学习!!!");
    }
}

访问权限修饰符

访问权限修饰符 :
                                     本类                     同包类                      不同包下的类                      不同包下的其他类
        private私有的                  √
        default默认的                  √                        √
        protected受保护的              √                        √                            √
        public公共的                   √                        √                            √                                  √

    注意:
        都是成员修饰符,只能修饰成员,不能修饰局部
        能够修饰类的 : public | default
        Protected修饰的成员在不同包下的子类中,需要通过继承关系使用
        最常用的两种权限 : public|private

    思考 : 父类中私有的成员,子类能够是否,能否继承?

public class Class001_Modifier {
   public String  testPublic = "public";
   protected String  testProtected = "protected";
   String  testDefault = "default";
   private String  testPrivate = "private";

    public static void main(String[] args) {
        new Class001_Modifier().test();
    }

   public void test(){
       //测试本类中使用
       System.out.println(testPublic);
       System.out.println(testProtected);
       System.out.println(testDefault);
       System.out.println(testPrivate);
   }

   public static void testStatic(){
       //测试本类中使用
       Class001_Modifier cm = new Class001_Modifier();
       System.out.println(cm.testPublic);
       System.out.println(cm.testProtected);
       System.out.println(cm.testDefault);
       System.out.println(cm.testPrivate);
   }

}
//同包类
class Demo{
    public static void main(String[] args) {
        //测试本类中使用
        Class001_Modifier cm = new Class001_Modifier();
        System.out.println(cm.testPublic);
        System.out.println(cm.testProtected);
        System.out.println(cm.testDefault);
        //System.out.println(cm.testPrivate);
    }
}

重写与重载

重写 与 重载 之间的区别 :
        都是方法的特性

        重载的实现条件 :
            1.一个类中的多个方法
            2.方法名相同
            3.参数列表不同|方法签名不同

        重写的实现条件:
            1.两个类
            2.继承|实现
            3.方法签名完全相同

    重写的需求 :
        当子类从父类中继承的功能满意,对功能实现不满意的时候,可以在子类对从父类中继承的功能重新实现

    调用使用 :
        如果子类中没有重写,调用父类的,父类没有报错
        如果子类存在重写方法,调用子类中重写后的方法,对父类的方法进行屏蔽

    检测是否为重写方法 :
        1.idea行号后面的位置出现o向上箭头
        2.在重写方法上添加注解 @Override

    不能被重写的方法 :
        1.被private修饰的方法不能被重写
            能被子类继承,但是无权使用
        2.被final修饰的方法不能被重写
        3.被static修饰的方法不能被重写
            可以被继承不能被重写
            如果子类中出现与父类中静态方法同名的方法,要求子类中这个同名的方法也被static修饰

public class Class001_Override {
    public static void main(String[] args) {
        SiCong siCong = new SiCong();
        siCong.words();
        siCong.test();
    }
}

class JianLin{
    String name = "王健林";

    //名人名言
    public static void words(){
        System.out.println("先定义小目标,挣它一个亿...");
    }

    public static void test(){}
}

class SiCong extends JianLin{
    String name = "王思聪";

    //重写方法
    public static void words(){
        System.out.println("我在不在乎我的朋友有钱没有,反正都没我有钱...");
    }
}

final关键字

    final 最终的
        被final修饰的变量为常量
        被final修饰的方法不能被重写
        被final修饰的类不能被继承-->太监类
        

JavaBean

Javabean :  一系列实体类的统称
        定义规范 :
            1.类是公共的
            2.至少一个空构造
            3.属性私有化
            4.提供一对公共的访问方式