Day8:面向对象编程2

super

1.子类的开头有隐藏代码super(),且调用父类的构造器调用super()时,super()必须在第一行.私有的(private)的变量或方法无法用super调用

2.倘若父类写了有参构造,可以写一个无参构造,不然子类的隐藏的super()无法编译,又或者写一个super(参数);

3.super()只能出现在子类的方法或构造器中,且this()与super()不能同时调用,此外

super()只能在继承条件中使用

方法重写

如果出现A,B两个方法,A继承B,可能出现以下情况(多态)

A a=new A();
B b=new A();

这是由于父类的引用指向了子类,子类重写了父类的方法

特点: 1.方法名必须相同

2.参数列表必须相同

3.修饰符范围可以放大但不能缩小.public>protected>Default>private

4.剖出的异常范围可以缩小但不能放大

为什么需要重写

因为父类的方法,子类不一定需要或满足

多态

关于多态,上述的方法重写已提及,简单来说就是右边的实际类型我们已经确定,

而左边的引用类型可以是子类自己本身,也可以是父类,甚至是object类

1.如果引用类型是子类本身,那么能调用的方法可以是自带的,也可以是父类的

此外引用类型是父类型,就不能调用子类型自带的方法,除非类型强制转换

2.多态是方法的多态,属性没有多态,另外引用类型必须有联系,如string与Teacher()就不能混用

3.存在条件:继承关系,方法重写,父类引用指向子类对象

4.不能使用多态的有:static方法属于类不属于实例;final常量;private方法

instanceof

instanceof可以判断新建对象与类之间的关系,若有关系就为true,反之为false

Object>Person>Student

Object>Person>Teacher

Object>String

public static void main(String[] args) {
        Object object=new Student();
        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Teacher);//false
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof String);//false
}

强制类型转换

Person p=new Studeng();
Student student=(Student) p;
student.study();
//便捷写法:((Student) p).study();

注意:子类转父类不需要强制转换,但可能丢失方法

关于静态与非静态方法(多态)的重写

当调用的Person类与Teacher类都为静态方法时,起决定作用的是左边相关的类

反之,只看右边的

Person类

public class Person {
    public  void say(){
        System.out.println("我要下课");
    }
}

Teacher类

public class Teacher extends Person{
    public  void say() {
        System.out.println("同学们好,上课");
    }
}

main方法

public static void main(String[] args) {
        Teacher teacher = new Teacher();
        teacher.say();
        Person person=new Teacher();
        person.say();
    }

static

java中有除了构造器外的隐藏代码,就是匿名代码块,和静态代码块,加载顺序为静态代码块>匿名代码块>构造器

import static java.lang.Math.PI;//静态导入包
public class Demo01 {
        {
            System.out.println("匿名代码块");
        }
        static{
            System.out.println("静态代码块");
        }
        public Demo01(){
            System.out.println("构造器");
        }
    public static void main(String[] args) {
        Demo01 demo01 = new Demo01();
        System.out.println(PI);//有第一行就能直接使用PI
    }
}

结果:

静态代码块
匿名代码块
构造器
3.141592653589793

抽象类

如果只是想写一个方法,而不写方法体,可以在类上加abstract抽象类;而在父类的抽象类,继承的子类必须实现其方法.同理若子类也是抽象类,那么子类也可不写方法体,让子类的子类写方法体

//父类
public abstract class Demo02 {
    public abstract void   dosomething();
}
//子类
public  class Demo01 extends Demo02 {
    public void dosomething(){
        //方法体
    }
}

注意:1.不能用new创建新对象

2.抽象方法必须声明在抽象类中,而抽象类中可以存在普通方法

接口

接口的本质就是契约,规定好就要去执行;class是声明类的关键字,而接口的关键字是interface;接口类的的所有的的对象都是抽象的,不需要写方法体

1.可以创建类实现接口,用implements关键字指向,就像继承一样格式

2.创建的类实现了接口的类就必须实现接口的方法

3.Java继承只有单继承,而利用接口可以实现多继承

//接口1
public interface Demo02 {
   void add();
}

//接口2
public interface Demo03 {
    void change();
}

//用于实现接口1,2方法的类
public class  Demo01 implements Demo02,Demo03 {
    @Override
    public void add() {

    }
    @Override
    public void change() {

    }
}