2021.7.29复习博客继承、方法重写、多态、instanceof和类型转换、static关键字、抽象类、接口、内部类

继承

关键字extends

extends的意思是扩展，子类是父类的扩展

继承是类和类之间的一种关系，子类可以继承父类的所有方法

举例:

//在同一个包下
public class dad{//父类
    public void say(){
        System.out.println("something");
    }
}
//另一个类
public class son extends dad(){
    
}
//在main方法中的调用
son Son = new son();
Son.say();//调用
//结果为：打印something
//注意：方法必须为public才可以直接调用

在Java中，所有的类，都默认直接或间接继承Object

ctrl+H可以查看当前继承的关系

子类调用父类的方法-----------super

举例：

//子类中的方法
public void test(String name){
    System.out.println(name);//输出形式参数的name
    System.out.println(this.name);//输出子类中的name
    System.out.println(super.name);//输出父类中的name
}

先父及子，继承父类后父类先执行

super的注意点：

1.super调用父类的构造方法，必须在构造方法的第一个

2.super必须只能出现在子类的方法或者构造方法中

3.super和this不能同时调用构造方法

与this相比：

代表的对象不同：

this：本身调用者这个对象

super：代表父类对象的应用

前提：

this：没有继承也可以使用

super：只能在继承条件下才可以使用

构造方法：

this():本类的构造

super():父类的构造

方法重写

public class A extends B{//子类A继承父类B
    public void test(){
        System.out.println("A=>test()");
    }
}
//父类B
public class B{
    public void test(){
        System.out.println("B=>test()");
    }
}
//main中调用
A a =new A();
a.test();//输出结果为A=>test()
B b =new A();
b.test();//输出结果为A=>test()
//如果A类和B类中的test为public static void test()
//则a.test输出A=>test()，b.test输出B=>test()

静态方法是类的方法，而非静态是对象的方法

有static时，b调用了B类的方法，因为b是B类定义的

没有static时，b调用的是对象的方法，而b是A类new的

静态方法和非静态方法区别很大！

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

非静态：重写；注意，重写需要有继承关系

重写：1方法名必须相同

2参数列表必须相同

3修饰符：范围可以扩大但不能缩小：public>Protected>Default>private

4抛出的异常：范围，可以被缩小但是不能扩大

父类的功能，子类不一定需要或不一定满足

alt+insert；override

多态

//Student是Person的子态
//Student能调用的方法都是自己的或者父类的
//Person父类型，可以指向子类，但是不能调用子类的独有的方法，s2无法调用s1特有的方法
Student s1 = new Student();
Person s2 = new Student();
Object s3 = new Student();
//对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
//两个类中有相同名称的方法时，执行子类的
//例如 两类中都存在run()这个方法
s1.run()；
s2.run();
//两者执行的都是子类Student中的run()方法

多态的注意事项：

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

2父类和子类，有联系

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

instanceof和类型转换

System.out.println(X instanceof Y);
//若X和Y之间存在父子关系则编译通过，否则报错
//X(对象)Y(类)，如果A是B本类或子类的对象，结果为true，否则为false

类型转换：

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

2把子类转换为父类，向上转型，可能会丢失子类中原本可以直接调用的方法

3把父类转换为子类，向下转型，需要强制转换，可能会丢失父类被子类所重写掉的方法

static关键字

在类(class)中，static方法或者static定义的变量与类一起加载，所以可以在类中各个地方任意调用，但是无法在static中调用非static方法或变量

static只执行一次，但是可以在不同地方多次调用

抽象类

关键词abstract

使用方法 在类(class)前加上abstract

抽象类中的方法可以没有内容，例如

public abstract void 自定义名称();//抽象类中的方法
//只有名字，没有方法的实验
//约束~有人帮我们实现

Java的类是单继承(extends)的，但是接口是可以多继承的(为后续铺垫)

不能new抽象类，只能靠子类去实现它，起到一个“约束”作用

抽象类中可以写普通方法，但是抽象方法必须在抽象类中

☆继承了抽象类的子类必须要重写抽象类的抽象方法(子类中写成普通方法)

☆接口

接口：只有规范，无法自己写方法，是专业的约束，约束和实现分离：面向接口编程

关键字interface

例子：

//接口关键字interface，每个接口都有实现类class
public interface UserService{//UserService为自定义名字，可以随便取
    //接口中所有的定义其实都是抽象的，自带public abstracr
    
}

接口中定义的int都为常量，默认有public static final修饰，但一般不用

举例：接口1

package com.scanner.userService;

public interface userService {
    void add();
    void delete();
    void update();
}

接口2

package com.scanner.userService;

public interface timeService {
    void timer();
}

接口类(用于实现接口所需的功能)：

package com.scanner.userService;
//Alt+insert一键插入接口想要实现的方法
public class userServiceImp1 implements userService,timeService{
    @Override
    public void add() {

    }

    @Override
    public void delete() {

    }

    @Override
    public void update() {

    }

    @Override
    public void timer() {

    }
}

接口的作用：

1约束

2定义一些方法让不同的人实现

3接口不能被实例化(new)接口中没有构造方法

4implements可以实现多个接口

5必须重写接口中的方法

内部类

在一个类的内部定义另一个类

在main中的调用

外部类名字 外部类的自定义命名 = new 外部类名字();//实例化
外部类名字.内部类名字 内部类的自定义命名 = 外部类名字.new 内部类名字();
//接下来是调用
内部类的自定义命名.内部类的方法名();