2022-07-26 第四小组 王星苹 学习笔记

😁😁学习心得😁😁

今天讲了接口，明白了接口和类的区别，接口存在的意义是，约定。在java中是存在多继承的，发生在接口之间。java类与类之间只有单继承。

😎😎心情😎😎

上午听的比较明白，下午讲的一些关于列表和栈的东西理解的不太全面，关于这个的顺序还要在练习一下

 

抽象：

* 抽象方法必须在一个抽象类里
* 1.当我们定义了一个抽象类，这个抽象类可以有哪些结构
*     属性 成员方法 构造器 抽象方法 常量
* 2.抽象类中能不能没有抽象方法？
*     抽象类中可以没有抽象方法
* 3.抽象类是不能被实例化的
*     抽象类不能创建对象
* 4.抽象类构造器存在的意义
*     为了约定子类的构造器必须要和父类的匹配
* 5.一个类如果继承了抽象类，就必须重写这个抽象类的全部抽象方法
*
* abstract能修饰什么？
*    类 方法
* 抽象方法能不能用private修饰
*    不能 开发中抽象方法都是public修饰
* 抽象方法能不能用final修饰？
*    不能，用final修饰时不能重写
* 抽象类能不能被final修饰？
*    不能，用final修饰的类是不能被继承的

 

* 接口
                                                                                                                                              
* 比抽象类更高级的抽象。
* 声明：使用interface关键字，public interface Ch02
* JDK1.7之前：接口中只能定义抽象方法，不能有属性，不能有方法。
*           （静态的常量）
* JDK8及以后：接口中只能定义抽象方法，不能有属性，可以有默认方法和静态方法
*            静态常量。
* JDK7---JDK8：默认方法，静态方法。
                                                                                                           
* 接口中结构的特点：
* 接口中的抽象方法默认是public abstract，我们推荐就省略了。
* 接口中的常量默认是public static final，我们推荐就省略了。

* 说一句话：接口中的结构必须是public。

* 接口可以被实现，实现类
* 比如说A类 implements 接口，那我们就说A是这个接口的实现类。

* 如果一个类实现了一个接口，它就需要重写接口中所有的抽象方法。

* 实现接口是可以多实现的，继承只能单继承。
* 开发中，如果一件事情可以通过继承和实现接口来解决问题，接口解决。
                                                                                            
* 面试题：
* 1.继承抽象类和实现接口的异同。
* 2.抽象类和接口的区别。
                                                                                             
  接口存在的意义？
  约定。
                                                                                                
* 多态的前提条件？
  1.继承，实现
  2.重写方法
  3.父类---子类，接口---实现类
                                                           
  面试题：
  在java中只有单继承？
  在java中是存在多继承的，发生在接口之间。
  java类与类之间只有单继承。
                                                            
* 面向对象编程
* 面向接口编程
* 面向切面编程
* 抽象类也是比类更高级的抽象。

练习题：

  需求：
  1.创建一个接口（电子产品），存储数据，导出数据
  2.创建一个电脑类，电脑类可以使用电子产品
  3.创建一个人，人有一台电脑，可以这台电脑存储数据和导出数据
  4.有一个真正的电子产品U盘，存储数据，导出数据
  5.有一个真正的电子产品MP3，存储数据，导出数据，听音乐
  6.这台电脑是可以使用者两种电子产品的运行效果不同。
  需求我写的也不是很清楚，你们可以发散思维，多考虑一些问题。

  电子产品

public interface ElectronicProduct {


        default void importData(){
            System.out.println("导入数据...");
        }


        default void exportData(){
            System.out.println("导出数据...");
        }
    }

  电脑类

public class Computer {


    public void use(ElectronicProduct electronicProduct) {
        if(electronicProduct instanceof UDisk) {
            UDisk uDisk = (UDisk) electronicProduct;
            uDisk.importData();
            uDisk.exportData();
        }else if(electronicProduct instanceof MP3) {
            MP3 mp3 = (MP3) electronicProduct;
            mp3.importData();
            mp3.exportData();
            mp3.music();
        }
    }
}

人的类

public class Person {


    private Computer computer;


    public Computer getComputer() {
        return computer;
    }


    public void setComputer(Computer computer) {
        this.computer = computer;
    }


    public void usePC(ElectronicProduct electronicProduct) {
        computer.use(electronicProduct);
    }
}

  U盘

public class UDisk implements ElectronicProduct {


}
//Mp3
public class MP3 implements ElectronicProduct {


    public void music(){
        System.out.println("MP3在播放音乐...");
    }
}

  测试

public class Demo {


    public static void main(String[] args) {
        Person person = new Person();
        Computer computer = new Computer();
//        UDisk uDisk = new UDisk();
        ElectronicProduct electronicProduct = new UDisk();
        electronicProduct = new MP3();
        person.setComputer(computer);
        person.usePC(electronicProduct);

                 栈和队列                                                                 

* 栈和队列：
* 栈和队列是两种操作受限的线性表。
*
* 这种受限表现在：
*  栈的插入和删除只允许在表的尾端进行（在栈中叫做“栈顶”），满足FILO
*      First In Last Out；
*  队列只允许在表位插入元素，在表头删除元素，FIFO First In First Out
*
*  栈与队列的相同点：
*  1.都是线性结构
*  2.插入操作都是在表尾进行
*  3.都可以通过顺序结构和链式结构实现。
*
*  栈与队列的不同点：
*  1.队列，先进先出，栈先进后出

                                                                                                                                                                                               

public class Stack {


    private SuperLinked superLinked = new SuperLinked();


    // 入栈。压栈
    public void push(Integer item){
        superLinked.add(item);
    }


    // 返回栈顶元素，不出栈
    public Integer peek(){
        if(empty()) {
            return null;
        }
        return superLinked.get(superLinked.size() - 1);
    }


    // 出栈，从栈尾出去
    public Integer pop(){
        if(empty()) {
            return null;
        }
        Integer integer = superLinked.get(superLinked.get(superLinked.size() - 1));
        superLinked.remove(superLinked.size() - 1);
        return integer;
    }


    private boolean empty() {


        return superLinked.size() == 0;
    }


    public static void main(String[] args) {
        // 测试
        Stack stack = new Stack();
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);


        stack.pop();


        System.out.println(stack.peek());

匿名实现类

public class Ch01 {


    public static void main(String[] args) {
        Ch01 ch01 = new Ch01();
        System.out.println("ch01=" + ch01);
        Abstr01 a01 = new Abstr01() {
            @Override
            public void show() {
                System.out.println("重写过后的show方法...");
            }
        };
        a01.show();
        Abstr01 abstr02 = new Ch02();
        System.out.println(a01);
        Inter01 inter01 = new Inter01() {
            @Override
            public void eat() {
                System.out.println("重写过后的eat方法...");
            }
        }
    }
}


public abstract class Abstr01 {
    public abstract void show();
}


public class Ch02 extends Abstr01 {
    @Override
    public void show() {
    }
}


public interface Inter01 {
    void eat();

 

重点记忆：

 栈与队列的不同点：
1.队列 先进先出，
2.栈 先进后出