Java——多态、接口、抽象类、静态等

多态

注意事项

• 多态是方法的多态

• 父类和子类，有联系 类型转换异常！

存在条件

继承关系+方法需要重写，两个类型都有的方法执行子类的方法

父类的引用指向的是子类对象

static方法不能重写，它属于类

final不能重写

private不能重写

属性没有多态

//一个对象的实际类型是确定的
  //可以指向的引用类型就不确定了
  //fan能调用的方法都是自己的或者继承父类的
  //父类可以指向子类但是不能调用子类独有的方法
  Fan s1=new Fan();
  Person1 s3=new Fan();
  Object s2=new Fan();

  s3.run();//子类重写父类的方法所以执行子类
  s1.run();
 // s3.eat();


  //对象能执行哪些方法主要看对象左边类型，和右边关系不大

  //父类的引用指向子类

instanceof关键字

类型转换，判断两个类之间又没有父子关系

X instanceof Y

X志祥的类型是否与Y有关系

    Object o=new Fan();
  System.out.println(o instanceof Person1);  //true
  System.out.println(o instanceof Fan);      //true
  System.out.println(o instanceof Object);   //true
  System.out.println(o instanceof Star);     //false
  System.out.println(o instanceof String);    //false
 
  
  关系图：
  Object > String
  Object > Person1 > Fan
  Object > Person1 > Star

Person1 p=new Fan();
  Person1 p=new Person1();
  System.out.println(p instanceof Person1);   //true 
  System.out.println(p instanceof Fan);       //true
  System.out.println(p instanceof Object);    //true
  System.out.println(p instanceof Star);      //false
  System.out.println(p instanceof String);    //编译错误

Fan p=new Fan();
System.out.println("888888888888888888888888");
System.out.println(p instanceof Person1);   //true
System.out.println(p instanceof Fan);       //true
System.out.println(p instanceof Object);    //true
System.out.println(p instanceof Star);      //编译报错

强制转化

//类型转化:父类  子类
  //高           低
  Person1 p=new Fan();
  //p.go();
  //将p转化为Fan类型，就可以使用Fan类的方法
// Fan p1= (Fan)p;
 //p1.go();
((Fan) p).go();

//类型转化:父类  子类
  //子类转化父类可能会丢失本来的方法
 Fan f=new Fan();
 f.go();
 Person1 p=f;//自动转化

• 父类引用指向子类对象

• 把子类转化为父类：向上转型不用强制

• 父类到子类：向下转型，需要强制转化

• 方便方法调用，减少重复代码

代码块

• 匿名代码块
• 静态代码块

package com.oop.Demo07;

public class Preson {
    {
        //代码块（匿名代码块）
        System.out.println("ninmdaimakuai ");
    }
    static {
        //静态代码块
        System.out.println("惊天代码库");

    }
    public Preson(){
        System.out.println("构造器");
    }

    public static void main(String[] args) {
        Preson p=new Preson();
        System.out.println("=================");
        Preson p2=new Preson();
    }
}

static

属性：
静态属性可以通过类直接调用

public class Student1 {
    private  static int age;//静态变量
    private  double score;//非静态变量

   
    public static void main(String[] args) {
        Student1 s=new Student1();
        System.out.println(Student1.age);
       // System.out.println(Student1.score);  出错
        System.out.println(s.age);
        System.out.println(s.score);
    }
}

方法：

package com.oop.Demo07;
//static
public class Student1 {
    private  static int age;//静态变量
    private  double score;//非静态变量

    public void run(){
        
    }
    
    public  static void go(){
        
    }

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

static代码块只执行一次

匿名代码块附初始值

package com.oop.Demo07;

public class Preson {
    {
        //代码块（匿名代码块）
        System.out.println("ninmdaimakuai ");
    }
    static {
        //静态代码块
        System.out.println("惊天代码库");

    }
    public Preson(){
        System.out.println("构造器");
    }

    public static void main(String[] args) {
        Preson p=new Preson();
        System.out.println("=================");
        Preson p2=new Preson();
    }
}

//类型转化:父类  子类
  //子类转化父类可能会丢失本来的方法
 Fan f=new Fan();
 f.go();
 Person1 p=f;//自动转化

抽象类

abstract关键词

特点：不能new，只能靠子类实现（继承） 注意是单继承

抽象方法必须在抽象类中

抽象的抽象：约束~

思考题：

抽象类存在构造器吗：有

存在的意义：提高开发效率

接口

普通类：只有具体的实现
抽象类：具体实现和规范（抽象爱那个方法）都有
接口：只有规范！自己无法写方法 专业的约束！约束和实现的分离：面向接口编程

接口就是规范，定义了一组规则
本质是契约

关键字：interface

接口需要类实现
实现了接口的类必须重写接口的方法

接口可以实现多继承

public class UserServiceImp implements UserService,Tine   //继承了两个接口
{
    @Override
    public void delete(String name) {

    }

    @Override
    public void add(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {
        
    }
}

总结：

1. 约束
2. 定义一些方法，让不同的人实现
3. public abstract
4. public static final
5. 接口不能被实例化，没有构造方法
6. 可以实现多个接口，用implements