luliyu-java-day09

__Miracle__

于 2021-07-19 15:19:14 发布

阅读量96

点赞数

分类专栏：学生

原文链接：https://mp.csdn.net/

版权

学生专栏收录该内容

110 篇文章 2 订阅

订阅专栏

接口的多实现

弥补单继承的不足, 一个类是可以实现多个接口的，这叫做接
口的多实现, 并且，一个类能继承一个父类，同时实现多个接口

class 类名 [extends 父类名]  implements 接口1, 接口2, ... {
		// 重写所有抽象方法
	
}

接口中，有多个抽象方法时，实现类必须重写所有抽象方法。如果抽象方法有重名的，只需要重写一次。

public interface A {
    public void  showA();
    public void  show();
}
public interface B {
    public void  showB();
    public void  show();
}

public class C implements A, B{
    @Override
    public void showA() {

    }

    @Override
    public void showB() {

    }

    @Override
    public void show() {

    }
}

接口中，有多个默认方法时，实现类都可继承使用。如果默认方法有重名的，必须重写一次

接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public
接口中，没有构造方法，不能创建对象。
接口中，没有静态代码块

多态：

是指同一行为，具有多个不同表现形式。

生活中，比如跑的动作，小猫、小狗和大象，跑起来是不一样的。再比如飞的动作，昆虫、鸟类和飞机，飞起来也
是不一样的。可见，同一行为，通过不同的事物，可以体现出来的不同的形态。多态，描述的就是这样的状态。

发生的条件

继承或者实现
方法的重写 (表现行为形式不同)
父类引用指向子类对象(格式的体现)
格式

父类 对象名 = new 子类()

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后方法。

public abstract class Animal {
    public abstract void eat();
}
public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("喵喵的吃");
    }
}

public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("康康的吃");
    }
}

public class Test {
    public static void main(String[] args) {
        // 多态形式创建对象
        // 父类 对象名 = new 子类()
        Animal cat = new Cat();
        cat.eat();

    }
}

多态好处

package com.claire.day09.duotaigood;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;

public class Test2 {
    public static void main(String[] args) {
        // 求数组中的最大值
        List<Integer> list1 = generate(10);
        List<Integer> list2 = generate2(10);
        System.out.println(list1);
        System.out.println(list2);
        getMax(list1);
        getMax(list2);

    }
    public static void getMax(List<Integer> list){
        int max = 0;
        for (int i = 0; i < list.size(); i++) {
            if (list.get(i) > max)
                max = list.get(i);
        }
        System.out.println("max = " +  max);
    }
    public static ArrayList<Integer> generate(int n){
        Random random = new Random();
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            list.add(random.nextInt(100));
        }
        return list;
    }
    public static LinkedList<Integer> generate2(int n){
        Random random = new Random();
        LinkedList<Integer> list = new LinkedList<>();
        for (int i = 0; i < n; i++) {
            list.add(random.nextInt(100));
        }
        return list;
    }
}

笔记本电脑案例

public interface USB {
    void  open();//开启
    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 Laptop {
    public void run(){
        System.out.println("笔记本运行");
    }
    // 使用USB设备 传入一个符合USB标准的类
    public void useUSB(USB usb){
        if (usb !=null){
            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 void useUSB(KeyBoard keyBoard){
//        keyBoard.open();
//        keyBoard.type();
//        keyBoard.close();
//    }
//    public void useUSB(Mouse mouse){
//        mouse.open();
//        mouse.click();
//        mouse.close();
//    }
    public void shutDown(){
        System.out.println("笔记本关闭");
    }
}

public class Test {

    public static void main(String[] args) {
        Laptop laptop = new Laptop();
        laptop.run();
        // 向上转型
        USB mouse = new Mouse();
        laptop.useUSB(mouse);
        USB keyBoard = new KeyBoard();
        laptop.useUSB(keyBoard);
        laptop.shutDown();

    }
}

final关键字

学习了继承后，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写。那么我们能不能随意的继承API中提供的类，改写其内容呢？显然这是不合适的。为了避免这种随意改写的情况，Java提供了final关键字，用于修饰不可改变内容

ﬁnal：不可改变。可以用于修饰类、方法和变量

类：被修饰的类，不能被继承。

public final class String{
}

方法：被修饰的方法，不能被重写。

public final void show(){
}

变量：被修饰的变量，不能被重新赋值。

package com.claire.day09.duotaigood;

public class Test3 {
    public static void main(String[] args) {
        final int a;
        a = 100;
//        a = 200; // 不能重新赋值
        final int b= 100;
//        b = 30;
//        下面写法会报错
//        final int c = 0;
//        for (int i = 0; i < 10; i++) {
//            c =i;
//            System.out.print(c);
//        }
       ;
        for (int i = 0; i < 10; i++) {
            // 每次循环重新创建 可以
            final int c = i;
            System.out.print(c);
        }
    }
}

权限修饰符

public：公共的。
protected：受保护的
default：默认的
private：私有的
在这里插入图片描述
可见，public具有最大权限。private则是最小权限。
编写代码时，如果没有特殊的考虑，建议这样使用权限：

成员变量使用private，隐藏细节。
构造方法使用public，方便创建对象。
成员方法使用public方便调用方法。
不加权限修饰符，其访问能力与default修饰符相同

内部类

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。


public class Car {
    class Engine{
        // 内部类
    }
}

特点

内部类可以直接访问外部类的成员，包括私有成员
外部类要访问内部类的成员，必须要建立内部类的对象。

package com.claire.day09.duotai;

public class Person {
    private  boolean live = true;


    class Heart{
        public void jump(){
            // 直接访问外部类成员
            if (live)
                System.out.println("心脏在跳动");
            else
                System.out.println("心脏不动了");
        }


    }

    public boolean isLive() {
        return live;
    }

    public void setLive(boolean live) {
        this.live = live;
    }

}

匿名内部类

匿名内部类：是内部类的简化写法。它的本质是一个带具体实现的
父类或者父接口的匿名的子类对象。
开发中，最常用到的内部类就是匿名内部类了。以接口举例，当你使用一个接口时，似乎得做如下几步操作，

定义子类
重写接口中的方法
创建子类对象
调用重写后的方法

匿名内部类必须继承一个父类或者实现一个父接口。

public abstract class FlyAble {
   public abstract void  fly();
}

public static void main(String[] args) {
       FlyAble f =  new FlyAble() {
           @Override
           public void fly() {
               System.out.println("飞飞飞");
           }
       };
       f.fly();
   }

__Miracle__

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
luliyu-java-day09

接口的多实现弥补单继承的不足, 一个类是可以实现多个接口的，这叫做接口的多实现, 并且，一个类能继承一个父类，同时实现多个接口class 类名 [extends 父类名] implements 接口1, 接口2, ... { // 重写所有抽象方法 }接口中，有多个抽象方法时，实现类必须重写所有抽象方法。如果抽象方法有重名的，只需要重写一次。public interface A { public void showA(); public void show();
复制链接

扫一扫

专栏目录