继承

java中所有的类,都默认直接或间接的继承Object

• 继承的本质是对某一批类的抽象,从而实现对现实世界更好的建模
• extends的意思是扩展.子类是父类的扩展
• Java只有单继承,没有多继承

public class Person {
	//    public    公共的(继承用这个)
	//    protected  受保护的
	//    default   默认的
	//    private   私有的
    public int money = 10000;
    public void say() {
        System.out.println("说刷了");
    }
}

public class Teacher extends Person{
}

public class Hello {
    public static void main() {
        Teacher teacher = new Teacher();
        teacher.say() //说刷了
    }
}

Super

public class Person {
	//    public    公共的(继承用这个)
	//    protected  受保护的
	//    default   默认的
	//    private   私有的
    public int money = 10000;
    public void say() {
        System.out.println("说刷了");
    }
}

public class Teacher extends Person{
 public Teacher() {
   super(); //默认会调用父类, 但是不展示
 }
  public void test() {
     super.say() //调用父类方法
  }
}

public class Hello {
    public static void main() {
        Teacher teacher = new Teacher();
        teacher.test() //说刷了
    }
}

Super注意点

1. super调用父类的构造方法, 必须在构造方法的第一行
2. super 必须只能出现在子类的方法或者构造方法中
3. super和this 不能同时调用构造方法

suber 和 this

• this: 本身调用, 没有继承也可以使用, 本类的构造
• super 代表父类对象的应用, 只能在继承条件才能使用,父类的构造

方法重写

1. 非静态方法才可以方法重写,
2. 只有 public标识符 才可以重写

public class A {
    public void test() {
        System.out.println("A=text");
    }
}

public class B extends A {
    @Override //方法重写
    public void test() {
        System.out.println("B=text");
    }
}

public class Application {
    public static void main(String[] args) {
//       非静态方法的调用和定义(左边)的有关
        B a = new B();
        a.test();//B=text
//        父类的引用指向了子类
        A b = new B();
        b.test();//B=text
    }
  }

public class A {
    public static void test() {
        System.out.println("A=text");
    }
}

public class B extends A {
    public static void test() {
        System.out.println("B=text");
    }
}

public class Application {
    public static void main(String[] args) {
//        静态方法的调用和定义(左边)的有关
        B a = new B();
        a.test();//B=text
//        父类的引用指向了子类
        A b = new B();
        b.test();//A=text
    }
  }

方法重写

需要有继承关系, 子类才能重写父类方法

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符 范围可以扩大, public > protected > default > private
4. 抛出异常: 范围可以缩小

子类的方法和父类方法必须一致, 方法体要不同

快捷键 alt + insert - > @Override

多态

public class Application {
    public static void main(String[] args) {
    // Teacher 能调用自己的方法或者继承父类的方法   (多态)
        Teacher t1 = new Teacher();
     // Person父类型,可以指向子类型,但不能调用子类型的独有方法,   (多态)
        Person t2 = new Teacher();
        t1.say2() // Teacher
        t2..test();// 会转换为((Teacher) b).test();  //类型转换
    }

public class Person {
    public void say2() {
        System.out.println("Person");
    }
}

public class Teacher extends Person{
     public void test() {
        System.out.println("test");
    }
    @Override
    public void say2() { //方法重写
        System.out.println("Teacher");
    }
}

多态注意事项

1. 多态是方法的动态, 属性没有多态
2. 存储条件,: 有继承关系, 方法需要重写, 父类的引用指向子类对象

不能重写,没有多态

• static 方法, 属于类, 他不属于实例
• final 常量
• private 方法

instanceof

System.out.printIn(A instanceof B) //验证A与B是否是继承关系

类型转换

public class Application {
    public static void main(String[] args) {
        Teacher t1 = new Teacher();
        Person t2 = new Teacher();
        ((Teacher) b).test();  //类型转换
    }
}

1. 类型引用指向子类的对象
2. 把子类转换为父类, 向上转型
3. 把父类转换为子类, 向下转型,强制转换
4. 方便方法调用,减少重复的代码