Java基础 day09

多态

  • 即同一个方法可以根据发送对象的不同而采取多种不同的行为方式

  • 一个对象的实际类型是确定的，但可以指向对象的引用类型有很多（父类、有关系的类）

  • 多态存在的条件

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

  • 注意：

    • 多态相对于方法而言的，属性没有多态性质
    • 父类和子类 类型转换异常---ClassCastException
    • 存在条件：继承关系，方法需要重写，父类引用指向子类对象 Father f = new son();
    • 不能被重写的方法有：
      • static修饰的方法 属于类，不属于实例
      • final修饰的方法 无法修改、重写
      • private修饰
//Student extends Person
//Student重写Person的run()方法，并独占一个study()方法
//一个对象的实际类型是确定的
new person();
new Student();

//可以指向的引用类型不确定
Student s1 = new Student();//指向自身
Person p1 = new Person();//指向父类Person

//子类重写父类方法，执行子类方法
s1.run();
p1.run();//都执行Student的run()方法
//实际类型是Person的实例，要调用Student的独占study()方法
//需要通过强制类型转换成Student类型，才可使用
((Student)p1).study();
  • 关键词：instanceof 类型转换 --主要是引用类型的转换

instanceof 和 类型转换

X instanceof Y X>>Y

//类型之间的转化：
Student s = new Student();
s.run();
Person p = new Person();
//子类转换成父类 隐式转换/自动转换/向上转换 
//但可能会丢失自己原本的方法
Person p = s;
//父类转换成子类 强制转换/向下转换
Student s2 = (Student)p;
s2.run();
//简写为：((Student)p).run();

类型转换作用：方便方法的调用

static总结 
class Student{
    
    private int age;
    public int birth;
    //***类加载机制
    public void run(){
        go();//非静态方法可以调用静态方法而静态方法调用不了非静态方法
        //因为静态修饰的方法和属性是和类一起加载的，而非静态的并未加载即不存在
    }
    
    public static void go(){
        
    }
    
    public static void main(String[] args){
        System.out.println(Student.age);
        (new Student).age;
        (new Student).birth;
        go();//由于在当前类中，可直接调用或Student.go();
        (new Student).run();
    }
    //下面三个的执行顺序依次是：静态代码块、匿名代码块、构造方法
    static{
        //静态代码块，只执行一次
    }
    
    {
        //匿名代码块，一般用来赋初始值
    }
    
    public Student(){
        //构造方法
    }
}

静态导入包

import static java.lang.Math.random;//此处的random为方法
import static java.lang.Math.PI;//PI为常量

public class test{
    public static void main(String[] args){
        //输出随机数
        System.out.println(random());
        System.out.println(PI);
    }
}
抽象类

abstract 关键字修饰，需要extends---被继承

  • 继承抽象类的类必须要实现其为实现的方法，除非也是抽象类。
  • 抽象方法，只有方法名，没有方法的实现！：规范
  • 不能被实例化，只能靠子类去实现它；
  • 抽象类可以写普通的方法，但抽象方法必须在抽象类中
  • 由于java(抽象)类只能单继承，所以出现了接口，接口可以多继承
  • 有构造方法，抽象类的子类构造方法会隐含父类的无参构造方法

意义

再次抽象，节省代码，提高开发效率，扩展性

接口***

interface关键字修饰，需要implement---被实现

  • 普通类：只有具体实现
  • 抽象类：具体方法和规范(抽象方法)都可以有
  • 接口：只有规范(抽象方法)，专业的约束！ 约束和实现分离：面向接口编程~

作用：

  • 接口就是规范，定义的是一组规则
  • 定义一些方法，让不同的人实现
  • public abstract修饰
  • 接口不能被实例化，接口中没有构造方法
  • implements可以实现多个接口，必须要重写接口中的方法
public interface UserService{
    //默认是常量 public static final,但一般不在这里定义常量
    int age = 99;
    
    //***接口中所有定义的方法其实都是抽象的public abstract
    void add(){
        
    }
    
}


public interface TimeService{
    //接口中所有定义其实都是抽象的public abstract
    
    void go(){
        
    }
    
}


public class UserService implements UserService,TimeService{
    //实现了接口的类，就要重写接口中的方法
    void go(){
        //
    }
    
    void add(){
        //
    }
}