多态，instanceof和类型转换，static关键字，抽象类和接口

多态

多态，即同一方法根据发送对象的不同而采用多种不同的行为方式。

多态存在的条件：

• 有继承关系
• 子类重写父类的方法
• 父类的引用指向子类的对象

多态是方法的多态。属性没有多态

不能被重写的方法：
              1.static 方法  是静态方法  属于类  不属于实例
              2.final 是在常量池里面的
              3.private 方法  是私有的 也不可以进行重写

instanceof和类型转换

instanceof 判断两个类之间是否有关系

public class Application {
    public static void main(String[] args) {
        Object object = new Student();
        Object object1 = new Teacher();

        //instanceof   判断两个类之间是否有关系
        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof Person);//true
        System.out.println(object1 instanceof Teacher);//true
        System.out.println(object instanceof String);//false

类型转换

1.父类引用指向子类的对象
2.把子类转换为父类，向上转型；不需要强制转换 会自动转换
3.把父类转换为子类，向下转换；需要强制转换
4.方便方法的调用，减少重复的代码！简洁

public class Student extends Person {
    public void go(){
        System.out.println("go");
    }
}

测试

    public static void main(String[] args) {
        //子类转换为父类可能会丢失自己本来的一些方法
        //类型之间的转化：
        //Person 父类（高）    Student 子类（低） 低转高 不需要强制转换
        Person dog = new Student();

        //dog 将这个对象转换为Student 类型  我们就可以使用Student 类型的方法了
        Student student = (Student) dog;
        student.go();
    }
}static

static关键字

//static
public class Student {

    private static int age;//静态变量  可以直接调用
    private double score;//非静态变量  需要实例化 然后再能调用

    public void run(){

    }
    public static void go(){

    }
    public static void main(String[] args) {
        new Student().run();
        Student.go();


        Student AAA = new Student();
        System.out.println(Student.age);
        System.out.println(AAA.age);
        System.out.println(AAA.score);
    }
}

public class Person {
    {   //第二个执行 赋初始值
        //代码块（匿名代码块）
        System.out.println("匿名代码块");
    }

    static { //第一个执行  但是只会执行一次
             //静态代码块
        System.out.println("静态代码块");
    }
    
    public Person(){ //第三个执行
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person Person1 = new Person();
        System.out.println("---------------");
        Person Person2 = new Person();
    }
}

抽象类

//abstract  抽象类 （接口可以多继承）
public abstract class Action {
        //约束~有人帮我们实现
        //在方法中加上 abstract 就是抽象方法，只有方法名字 没有方法的实际
        public abstract void doSomething();
        //1.抽象类不能new，只能靠子类去实现他。
        //2.抽象类中可以写普通方法，但是抽象方法必须在抽象类中。
        //抽象的抽象
}

抽象类的所有方法，必须要由子类实现，除非继承它的子类也是抽象方法则不需要实现

抽象类 存在构造方法

通过abstract class定义抽象类 只能通过extends去继承，所以是单继承的

接口

接口首先用interface关键字来定义接口，然后子类要实现的话 要通过implements关键字实现这个接口之后，再重写里面的方法就可以了。

接口是多继承

接口的作用：
          1.Java的接口是一个约束
          2.可以让我们定义一些方法 让不同的人实现 但是有多重不同的实现方式
          3.所有的方法都是public abstract 抽象的
          4.所有的常量都是public static final 的
          5.接口不能直接被实例化，因为接口没有构造方法
          6.接口可以实现多个，需要通过implements来实现多个接口，但是实现接口 必须要重写接口中的方法

接口

//通过interface 来定义接口 不在需要class
//接口都需要有实现类
public interface UserService {
    //属性也是默认的 默认的是一个常量静态的常量 public static final

   public static final int age = 99;

    //接口中的所有定义都是抽象的 ，接口中的方法如果不写  会默认就是 public abstract 抽象的
    void delete(String name);
    void query(String name);
}

实现接口

//类 可以实现接口 通过implements一个接口
//实现了接口的类，必须要重写接口里的所有方法

//利用接口实现多继承，
public class UserServiceImp1 implements UserService,TimeService{
    @Override
    public void delete(String name) {

    }

    @Override
    public void query(String name) {

    }


    @Override
    public void timer() {

    }
}