Java学习_20220609

1. 重写overvide补充：

（1）静态方法：方法的调用只和左边定义的数据类型有关；

（2）非静态方法：重写，修饰符只能为public。

2. 多态（在继承和重写的条件下）

定义：同一个方法可以根据发送对象的不同而采用多种不同的行为方式。

同一个 操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。

public class Person { //父类 public void run(){ System.out.println("father run"); } public void eat(){ System.out.println("father eat"); } } public class Student extends Person { //子类 @Override //重写（注解：有功能的注释） public void run() { System.out.println("son run"); } public void sleep(){ System.out.println("son sleep"); } } public static void main(String[] args) { //一个对象的实际类型是确定的 Student student = new Student(); Person person = new Person(); //一个对象可以指向的引用类型不确定,父类的引用指向子类 //Student 能调用的方法都是自己的或者继承父类的 Student S1 = new Student(); //Person 父类型，可以指向子类，但不能调用调用子类独有的方法 Person S2 = new Student(); Object S3 = new Student(); //在运行的时候才知道调用的是谁的方法，哪个类型的就执行谁的，但两个都有的话就执行子类的 S1.run(); //son run S2.run(); //son run 父类的引用指向了子类，调用子类的方法 person.run(); //father run 引用指向自己，调用自己的方法 S1.eat(); //father eat S2.eat(); //father eat Student中没有重写eat方法，只能继承Person中的方法 S1.sleep(); //son sleep //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大。 ((Student) S2).sleep(); //父类中没有sleep方法，若要使用必须强制将类型转换为Student }

注意事项：

（1）多态是方法的多态， 属性没有多态；

（2）多态是父类和子类之间的联系，否则会报异常  ClassCastException!

（3）存在条件：继承关系，方法需要重写， 父类引用指向子类对象！  Father  f1  =  new  Son ( ) ;

      不能被重写的方法：1. static  方法，属于类，它不属于实例；

           2. final 常量；

           3. private 私有方法。

instanceof 关键字

    Object > String

    Object > Person > Student

    Object > Person > Teacher

System.out.println(X instanceof Y)  // 能不能编译通过取决于X和Y之间是否存在父子关系

类型转换：  父类转换为子类，向下转型（高转低：强制转换）      子类转换为父类，向上转型（低转高 ：不用强转）

//高                  低
Person stu = new Student();
//调用Student中独有的方法
stu.go(); //无法调用，必须强制转换
//将stu这个对象转换为Student类型，就可以使用Student类型的方法了
Student student = (Student) stu;
student.go();
//可以写为一句话 ((Student) stu).go();
Person person = student;
person.go()//得强制转换为Student
//子类转换为父类，可能会丢失自己的本来的一些方法

 3. 静态类（static）

private  static  int age;
private  double score;
//调用
System.out.println(Person.age); //静态方法 类名.变量
Person p1 = new Person();  
p1.score = 2.1;  //非静态方法 实例化一个对象  对象名.变量
p1.age = 12; //静态方法也可以实例化一个对象
System.out.println(p1.score);
System.out.println(p1.age);

 静态变量对该类而言在内存中只有一个，可以被类中所有实例去共享

 静态方法：类名.方法( )  // 方法( )

非静态方法：实例化对象，对象名.方法( )    也可以调用静态方法中的所有东西

public class Person { 
    { 
        //匿名代码块 赋初始值
    }
    static{ 
        //静态代码块  执行一次
    }
    public Person(){
        //构造方法
    }
    public static void main(String[] args){
        Person p1 = new Person();  //静态->匿名->构造
        Person p2 = new Person(); //匿名->构造
    }
}

 4.抽象类（abstract）

普通的类：  public class fun(){}

普通的方法：public void  method(){}

抽象类和抽象方法：

//抽象类
public abstract class Action {
    //抽象方法，只有方法名字，没有实现
    public abstract void something();
}
//继承了抽象类的子类，必须实现抽象类中的所有方法
public class A extends Action {
    @Override
    public void something() {
        System.out.println("do something！");
    }
}

注意点：

（1）不能new这个抽象类，只能靠子类去实现它。（不能被实例化）

（2）在一个类中存在静态方法，那该类必为抽象类，但在抽象类中可以写普通的方法。

5.接口（interface）

//interface 定义的关键字，接口都需要有实现类
public interface UserService {
    //在接口中定义常量：public static final
    int age = 13;
    //接口中的所有定义都是抽象的，关键字：public abstract
    void add();
    void delete();
}
//抽象类是使用 extends，单继承
//类可以实现接口，使用imples 接口名称
//实现了接口的类，就需要重写接口中的方法
//可利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService {
    @Override
    public void add() {
    }
    @Override
    public void delete() {
    }
    @Override
    public void timer() {
    }
}

 作用：

（1）约束

（2）定义一些方法，让不同的人用不同的方式去实现

（3）接口不能被实例化，接口中没有构造方法

（4）使用implements实现多个接口

（5）类实现接口必须要重写接口中的方法

（6）在接口中定义常量：public static final，接口中的所有定义都是抽象的，关键字：public abstract