java基础复习02

java基础复习

面对对象

2.3、继承

继承是多态的前提，如果没有继承，就没有多态。

继承关系当中的特点:
1.子类可以拥有父类的“内容”
2.子类还可以拥有自己专有的内容。

在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种方式

直接通过子类对象访问成员变量:

等号左边是谁，就优先用谁,没有则向上找。

间接通过成员方法访问成员变量:

该方法属于谁，就优先用谁，没有则向上找。

区分子类方法中重名变量：

局部变量：直接写成员变量名
本类的成员变量: this.成员变量名
父类的成员变量： Super.成员变量名

重写和重载

重写(Override)

概念:在继承关系当中,方法的名称一样,参数列表也—样。

重写（Override) :方法的名称一样，参数列表【也一样】。覆盖、覆写。
重载（Overload):方法的名称—样，参数列表【不一样】。

方法的覆盖重写特点:创建的是子类对象,则优先用子类方法。

方法重写的注意事项：

必须保证父子类之间方法的名称相同，参数列表也相同。
- @Override:写在方法前面，用来检测是不是有效的正确覆盖重写。
  这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。
子类方法的返回值必须【小于等于】父类方法的返回值范围。
- 小扩展提示:java.Lang.object类是所有类的公共最高父类（祖宗类)，java.Lang.String就是object的子类。
子类方法的权限必须【大于等于】父类方法的权限修饰符。
- 小扩展提示: public > protected > (default) > private
  备注:(default)不是关键字default，而是什么都不写，留空。

重写设计原则：

对于已经投入使用的类，尽量不要进行修改。推荐定义一个新的类，来重复利用其中共性内容，并且添加改动新内容。

public class Phone {
    public void call(){
        System.out.println("打电话");
    }
    public void send(){
        System.out.println("发短信");
    }
    public void show(){
        System.out.println("显示号码");
    }
}

public class NewPhone extends Phone{
    @Override
    public void show() {
        super.show();
        System.out.println("显示姓名");
        System.out.println("显示头像");
    }
}

public class DemoPhone {
    public static void main(String[] args) {
        Phone phone = new Phone();
        phone.call();//打电话
        phone.send();//发短信
        phone.show();//显示号码
        System.out.println("-----------");

        NewPhone newPhone = new NewPhone();
        newPhone.call();//打电话
        newPhone.send();//发短信
        newPhone.show();//显示号码 显示姓名 显示头像
    }
}

2.4、抽象方法和抽象类

抽象方法:
就是加上abstract关键字，然后去掉大括号，直接分号结束。

抽象类:
抽象方法所在的类，必须是抽象类才行。在class之前写上abstract即可。

public abstract class Animal{
    public abstract void eat();
    
}

如何使用抽象类和抽象方法:

不能直接创建new抽象类对象。
必须用一个子类来继承抽象父类。
子类必须覆盖重写抽象父类当中所有的抽象方法。
- 重写(实现):子类去掉抽象方法的abstract关键字，然后补上方法体大括号。
创建子类对象进行使用。

2.5、接口

接口就是多个类的公共规范。

接口是一种引用数据类型，最重要的内容就是其中的:抽象方法。

如何定义一个接口的格式：

public interface 接口名称{
    //接口内容
}

如果是Java 7，那么接口中可以包含的内容有：

常量
抽象方法

如果是Java 8，还可以额外包含有:

默认方法
静态方法

如果是Java 9，还可以额外包含有：

私有方法

接口的抽象方法定义

在任何版本的Java中,接口都能定义抽象方法。格式:

public abstract 返回值类型方法名称(参数列表);

注意事项:

1、接口当中的抽象方法，修饰符必须是两个固定的关键字: public abstract

2、这两个关键字修饰符，可以选择性地省略。

3、方法的三要素，可以随意定义。

public interface MyInterface {
    //这是抽象方法
    public abstract void method();
    
    //这是抽象方法
    abstract void method1();
    
    //这是抽象方法
    public void method2();
    
    //这是抽象方法
    void method3();

}

接口的使用

接口使用步骤:

接口不能直接使用，必须有一个“实现类”来“实现”该接口。格式:
- public class 实现类名称 implements 接口名称{}
接口的实现类必须覆盖重写(实现)接口中所有的抽象方法。实现:去掉abstract关键字，加上方法体大括号。
创建实现类的对象,进行使用。

public class MyInterfaceImpl implements MyInterface{
    @Override
    public void method() {
        System.out.println("这是第一个方法");
    }

    @Override
    public void method1() {
        System.out.println("这是第二个方法");
    }

    @Override
    public void method2() {
        System.out.println("这是第三个方法");
    }

    @Override
    public void method3() {
        System.out.println("这是第四个方法");
    }
}

public class DemoInterface {
    public static void main(String[] args) {
        MyInterfaceImpl myInterface = new MyInterfaceImpl();
        myInterface.method();//这是第一个方法
        myInterface.method1();//这是第二个方法
        myInterface.method2();//这是第三个方法
        myInterface.method3();//这是第四个方法
    }
}

接口的默认方法的使用

从Java8开始，接口里允许定义默认方法。格式:

public default 返回值类型方法名称(参数列表){
方法体 }

备注:接口当中的默认方法，可以解决接口升级的问题

接口的默认方法，可以通过接口实现类对象，直接调用。
接口的默认方法,也可以被接口实现类进行覆盖重写。

public interface MyInterfaceDefault {
    //抽象方法
    public  abstract void method();
    
    //默认方法，如果实现类中没有，则会向上找接口
    public default void method1(){
        System.out.println("这是新的默认方法");
    }
}

接口的静态方法的使用

从Java 8开始，接口当中允许定义静态方法。格式:

public static 返回值类型方法名称(参数列表)

提示:就是将abstract或者default换成static即可，带上方法体。

public interface MyInterfaceStatic {
    
    public static void method(){
        System.out.println("这是接口的静态方法");
    }
}

注意事项:
- 不能通过接口实现类的对象来调用接口当中的静态方法。
- 正确用法:通过接口名称，直接调用其中的静态方法。
格式：
- 接口名称.静态方法名(参数);。

接口的私有方法的使用

问题描述:

我们需要抽取一个共有方法，用来解决两个默认方法之间重复代码的问题。但是这个共有方法不应该让实现类使用，应该是私有化的。

解决方案: 从Java 9开始,接口当中允许定义私有方法。

普通私有方法,解决多个默认方法之间重复代码问题格式:
- private 返回值类型方法名称(参数列表)
静态私有方法，解决多个静态方法之间重复代码问题格式:
- private static 返回值类型方法名称(参数列表)

public interface MyInterfacePrivate {
    public default void method1(){
        System.out.println("默认方法1");
        methodCom();
    }

    public default void method2(){
        System.out.println("默认方法2");
        methodCom();
    }

    private void methodCom(){
        System.out.println("aaa");
        System.out.println("bbb");
        System.out.println("ccc");
    }
}

接口中的常量

接口当中也可以定义“成员变量"”，但是必须使用public static final三个关键字进行修饰。
从效果上看，这其实就是接口的【常量】。

注意事项：
1、接口当中的常量，可以省略public static final，注意。不写也照样是这样。
2、接口当中的常量，必须进行赋值;不能不赋值。
3、接口中常量的名称，使用完全大写的字母，用下划线进行分隔。(推荐命名规则）

public interface MyInterfaceConst {
    
    public static final int NUM_OF_MY_CLASS= 12;
}

使用接口注意事项

接口是没有静态代码块或者构造方法的。
一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。格式:
- public class MyInterfaceImpl implements MyInterfaceA，MyInterfaceB {
  覆盖重写所有抽象方法}
如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。
如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。
如果实现类所实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。
一个类如果直接父类当中的方法，和接口当中的默认方法产生了冲突，优先用父类当中的方法。

接口之间的多继承

1.类与类之间是单继承的。直接父类只有一个。
2.类与接口之间是多实现的。一个类可以实现多个接口。
3.接口与接口之间是多继承的。

注意事项:
1、多个父接口当中的抽象方法如果重复,没关系。
2、多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，（而且带着default关键字）

2.6、多态

extends继承或者implements实现，是多态性的前提。

代码当中体现多态性，其实就是一句话:父类引用指向子类对象。
格式:
父类名称对象名= new 子类名称();
或者:
接口名称对象名= new 实现类名称();

public class fu {
    public void method(){
        System.out.println("这是父类方法");
    }
    public void methodFu(){
        System.out.println("这是父类特有方法");
    }
}

public class zi extends fu{
    @Override
    public void method() {
        System.out.println("这是子类方法");
    }
}

public class DemoMulti {
    public static void main(String[] args) {
        fu object = new zi();
        object.method();//这是子类方法
        object.methodFu();//这是父类特有方法
    }
}

注意事项

访问成员变量的方式：

直接通过对象名称访问成员变量:看等号左边是谁，优先用谁，没有则向上找。
间接通过成员方法访问成员变量:看该方法属于谁，优先用谁，没有则向上找。

访问成员方法的方式：

看new的是谁，就优先用谁，没有则向上找。

对象的向上转型

对象的向下转型

向上转型一定是安全的,没有问题的,正确的。但是也有一个弊端:

对象一旦向上转型为父类，那么就无法调用子类原本特有的内容。

解决方案: 用对象的向下转型还原

instanceof关键字

笔记本USB接口案例

public interface USB {

    public abstract void open();//打开设备

    public abstract void close();//关闭设备
}

public class Mouse implements USB{
    @Override
    public void open() {
        System.out.println("打开鼠标");
    }

    @Override
    public void close() {
        System.out.println("关闭鼠标");
    }

    public void click(){
        System.out.println("点击鼠标");
    }
}

public class Keyboard implements USB{
    @Override
    public void open() {

        System.out.println("打开键盘");
    }

    @Override
    public void close() {

        System.out.println("关闭键盘");
    }

    public void type(){
        System.out.println("键盘输入");
    }
}

public class Computer {
    public void powerOn(){
        System.out.println("笔记本开机");
    }

    public void powerOff(){
        System.out.println("笔记本关机");
    }
//使用USB设备的方法，使用接口作为方法的参数
    public void useDevice(USB usb){
        usb.open();//打开设备
        if (usb instanceof Mouse){//先判断
            Mouse mouse = (Mouse) usb;//向下转型
            mouse.click();
        }else if (usb instanceof Keyboard){//先判断
            Keyboard keyboard = (Keyboard) usb;//向下转型
            keyboard.type();
        }
        usb.close();//关闭设备
    }
}

public class DemoMain {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.powerOn();

        USB usbMouse = new Mouse();//向上转型
        computer.useDevice(usbMouse);//参数是usb类型，刚好我传进去的就是USB鼠标

        Keyboard keyboard = new Keyboard();//没有使用多态写法
        computer.useDevice(keyboard);//正确写法，也发生了向上转型，参考int向double转型

        computer.powerOff();

    }
}

posted @ 2021-07-27 13:57 飞翔奥尔良烤翅阅读(44) 评论(0) 收藏举报

刷新页面返回顶部

飞翔奥尔良烤翅