学习笔记——栈、队列

一、学习重点

二、学习内容

接口的简单实现案例

package com.jsoft.morning.test02;


/*
    需求：
    1、创建一个接口（电子产品），存储数据，导出数据
    2、创建一个电脑类，电脑类可以使用电子产品
    3、创建一个人，人有一台电脑，可以这台电脑存储数据和导出数据
    4、有一个真正的电子产品U盘，存储数据，导出数据
    5、有一个真正的电子产品MP3，存储数据，导出数据，听音乐
    6、这台电脑是可以使用者两种电子产品的运行效果不同
 */
public class Demo {
    public static void main(String[] args) {
        Person person = new Person();
        Computer computer = new Computer();
        ElectronicProduct electronicProduct = new UDisk();//开发尽量用多态，可读性强
        electronicProduct = new MP3();
        person.setComputer(computer);
        person.usePC(electronicProduct);
    }
}
package com.jsoft.morning.test02;
/*
    电子产品
 */
public interface ElectronicProduct {
    void importData();
    void exportData();
}
package com.jsoft.morning.test02;

public class Computer{

    public void use(ElectronicProduct electronicProduct){
        if (electronicProduct instanceof UDisk){
            ElectronicProduct electronicProduct1 = new UDisk();
        }
    }
}
package com.jsoft.morning.test02;

public class UDisk implements ElectronicProduct {
    @Override
    public void importData() {
        System.out.println("U盘在导入数据");

    }

    @Override
    public void exportData() {
        System.out.println("U盘在导出数据");

    }
}
package com.jsoft.morning.test02;

public class MP3 implements ElectronicProduct {
    @Override
    public void importData() {
        System.out.println("MP3在导入数据");
    }

    @Override
    public void exportData() {
        System.out.println("MP3在导出数据");

    }

    public void Music() {
        System.out.println("听音乐");

    }
}
package com.jsoft.morning.test02;

public class Person extends Computer  {
    private Computer computer;

    public Computer getComputer() {
        return computer;
    }

    public void setComputer(Computer computer) {
        this.computer = computer;
    }
    public void usePC(ElectronicProduct electronicProduct){
        computer.use(electronicProduct);
    }
}

图形类

package com.jsoft.morning.test;
/*
    图形类
    可以有几个属性:
        边长，角度，高
    创建子类：
        正方形、长方形、三角形、圆柱体、圆锥体、梯形···
 */
public abstract class Graphics {

    public abstract Double area(Double...args);
    public abstract Double volum();
    public abstract Double perimeter();
    
}
package com.jsoft.morning.test;

/**
 * 只能传入一个参数，即为圆的半径
 */
public  class Circle extends Graphics {
    @Override
    public Double area(Double ... args) {
        if (args.length>1){
            throw new RuntimeException("只能传入一个参数");
        }
        return 3.14 * args[0] * args[0] ;
    }

    @Override
    public Double volum() {
        return null;
    }

    @Override
    public Double perimeter() {
        return null;
    }
}
package com.jsoft.morning.test;

public class Trapezoid extends Graphics {
    @Override
    public Double area(Double... args) {
        return ((args[0]+args[1])*args[2])/2;
    }

    @Override
    public Double volum() {
        return null;
    }

    @Override
    public Double perimeter() {
        return null;
    }
}

栈

package com.jsoft.afternoon;

import com.jsoft.afternoon.linked.SuperLinked;

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.size()-1);
        superLinked.removeLast();
        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());
    }

}

队列

package com.jsoft.afternoon;
//队列
import com.jsoft.afternoon.linked.SuperLinked;

public class Queue {
    private SuperLinked superLinked = new SuperLinked();
    //入队
    public void add(Integer item){
        superLinked.add(item);
    }
    //出队
    public Integer poll(){
        //判断这个队列是不是null
        if (empty()){
            return null;
        }
        //找到队列的头
        Integer integer = superLinked.get(0);
        //把队伍的头删掉
        superLinked.removeFirst();
        //返回删除的值
        return integer;
    }
    //返回队首,不出队只是查看第一个元素
    public Integer peek(){
        if (empty()){
            return null;
        }
        return superLinked.get(0);
    }
    public boolean empty(){
//        if (superLinked.size() == 0){
//            return true;
//        }
//        return false;
        return superLinked.size() == 0;//代码重构
    }

    public static void main(String[] args) {
        Queue queue = new Queue();
        queue.add(1);
        queue.add(13);
        queue.add(126);

        queue.poll();

        System.out.println(queue.peek());
    }
}

银行取票机

package com.jsoft.afternoon.test;

import com.jsoft.afternoon.Queue;

import java.util.Scanner;

/*
    银行取票机
    队列
 */
public class BankTicketMachine {
    //需要一个队列结构
    private Queue queue = new Queue();

    private int startNumber = 100;

    private Scanner scanner = new Scanner(System.in);

    //取票
    public Integer getTicket(){
        if (queue.empty()){
            System.out.println("号码已经全部领取,需要继续释放号码的个数！");
            System.out.println("请输入释放号码的个数：");
            Integer number = scanner.nextInt();
            pushTicket(number);
        }
        return queue.poll();
    }
    //排队
    public  void pushTicket(int ticketNumber){
        for (int i = 0; i < ticketNumber; i++) {
            startNumber += i;
            queue.add(startNumber);
        }
    }
    public void run(){
        while (true){
            System.out.println("请输入你的名字");
            String name = scanner.next();
            Integer ticket = getTicket();
            System.out.println("尊敬的"+name+"您的号码是"+ticket);
        }
    }

    public static void main(String[] args) {
//        BankTicketMachine bankTicketMachine = new BankTicketMachine();
        new BankTicketMachine().run();//匿名
    }
}

面向对象-综合实例-马戏团

package com.jsoft.ooproject;
/*
    需求分析：
    1. 整个项目由三个环节组成：
        表演菜单展示-视图
        选择表演者进行表演 控制 -》业务
        选择是否继续观看表演-视图 IPO input Process Output
2. 使用面向对象思想编程
        对封装、继承和多态的使用
        注意编码规范
        注意循环的使用
 */
public interface IAct {
    String skill();
    String act();
}
package com.jsoft.ooproject;

public abstract class Animal {
    private String name;//昵称（name）
    private Integer age;//年龄（age）

    public Animal() {
    }

    public Animal(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
    //抽象方法：描述喜好
    public abstract String love();
}
package com.jsoft.ooproject;

public class Bear extends Animal implements IAct {
    public Bear() {
    }

    public Bear(String name, Integer age) {
        super(name, age);
    }


    @Override
    public String love() {
        return "喜欢卖萌";
    }

    @Override
    public String skill() {
        return "技能：挽着花篮，打着雨伞，自立走秀";
    }

    @Override
    public String  act() {
        return "表演者："+super.getName()+"\n年龄"+super.getAge()+"\n技能"+this.skill()+"\n爱好"+this.love();
    }
}
package com.jsoft.ooproject;

public class Lion extends Animal implements IAct {
    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Lion() {
    }

    public Lion(String name, Integer age) {
        super(name, age);
    }

    public Lion(String color, String sex) {
        this.color = color;
        this.sex = sex;
    }

    public Lion(String name, Integer age, String color, String sex) {
        super(name, age);
        this.color = color;
        this.sex = sex;
    }

    @Override
    public String love() {
        return "喜欢吃各种各样的肉";
    }

    @Override
    public String skill() {
        return "技能：擅长钻火圈";
    }

    @Override
    public String act() {
        return "表演者："+super.getName()+"\n年龄"+super.getAge()+"性别"+this.getSex()+"毛色"+this.getColor()+"\n技能"+this.skill()+"\n爱好"+this.love();
    }
    private String color;
    private String sex;
}
package com.jsoft.ooproject;

public class Monkey extends Animal implements IAct {
    public Monkey() {
    }

    public Monkey(String name, Integer age) {
        super(name, age);
    }

    public Monkey(String type) {
        this.type = type;
    }

    public Monkey(String name, Integer age, String type) {
        super(name, age);
        this.type = type;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    @Override
    public String love() {
        return "喜欢模仿人类的动作";
    }

    @Override
    public String skill() {
        return "技能：骑独轮车过独木桥";
    }

    @Override
    public String act() {
        return "表演者："+super.getName()+"\n年龄"+super.getAge()+"\n技能"+this.skill()+"\n爱好"+this.love()+"品种"+this.getType();
    }
    private String type;
}
package com.jsoft.ooproject;

public class Parrot extends Animal implements IAct {
    private String type;

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public Parrot() {
    }

    public Parrot(String name, Integer age) {
        super(name, age);
    }

    public Parrot(String type) {
        this.type = type;
    }

    public Parrot(String name, Integer age, String type) {
        super(name, age);
        this.type = type;
    }

    @Override
    public String love() {
        return "喜欢嗑瓜子";
    }

    @Override
    public String skill() {
        return "技能：模仿别人说话";
    }

    @Override
    public String act() {
        return "表演者："+super.getName()+"\n年龄"+super.getAge()+"\n技能"+this.skill()+"\n爱好"+this.love()+"品种"+this.getType();
    }
}
package com.jsoft.ooproject;

public class Clown implements IAct {
    public String name;
    public Integer age;
    public Clown() {
    }

    public Clown(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String skill() {
        return "搞笑";
    }

    @Override
    public String act() {
        return "名字"+this.getName()+"\n年龄"+this.getAge()+"\n技能"+this.skill();
    }
}
package com.jsoft.ooproject.view;

import com.jsoft.ooproject.*;

import java.util.Scanner;
//控制台
public class Controller {
    public void menu(){
        boolean flag = true;
        IAct iAct = null;
        while (flag){
            ShowMenu.show();
            Scanner scanner = new Scanner(System.in);
            int input = scanner.nextInt();
            switch (input){
                case 1:
                    iAct = new Bear("Bill",1);
                    System.out.println(iAct.act());
                    break;
                case 2:
                    iAct = new Lion("金毛狮王",1,"金色","公");
                    System.out.println(iAct.act());
                    break;
                case 3:
                    iAct = new Monkey("tom",1,"金丝猴");
                    System.out.println(iAct.act());
                    break;
                case 4:
                    iAct = new Parrot("Rose",1,"金刚鹦鹉");
                    System.out.println(iAct.act());
                    break;
                case 5:
                    iAct = (IAct) new Clown("Zero",20);
                    System.out.println(iAct.act());
                    break;
                default:
                    System.out.println("请输入正确的数");
                    continue;
            }
            System.out.println("*******是否继续观看(1/2)*********");
            int input2 = scanner.nextInt();
            switch (input2){
                case 1:
                    flag = true;
                    break;
                case 2:
                    flag = false;
                    System.out.println("*********欢迎下次观看*************");
                    break;
            }
        }
    }
}
package com.jsoft.ooproject.view;
//视图
public class ShowMenu {
    public static void show() {
        System.out.println("***********欢迎来到太阳马戏团***********");
        System.out.println("*********** 请选择表演者 ***********");
        System.out.println("*********** 1、棕熊 ***********");
        System.out.println("*********** 2、狮子 ***********");
        System.out.println("*********** 3、猴子 ***********");
        System.out.println("*********** 4、鹦鹉 ***********");
        System.out.println("*********** 5、小丑 ***********");
    }
}
package com.jsoft.ooproject.view;
//启动
public class Start {
    public static void main(String[] args) {
       Controller controller = new Controller();
       controller.menu();
    }
}

三、笔记内容

抽象方法，没有大括号，没有方法体

抽象方法存在的意义：根本意义是约定

约定：自定义的规则

抽象方法约定了什么规定了什么，定了哪些规则？

约定了返回值约定了访问权限约定了参数列表需要再重写的时候去定义方法体

约定大于配置，配置大于编码

抽象方法必须在一个抽象类里 public abstract class 类名(){}

1、当我们定义了一个抽象类，这个抽象类中可以有哪些结构？

属性、成员方法、构造器、抽象方法、常量

2、抽象类中可以没有抽象方法

3、抽象类是不能被实例化的

抽象类不能创建对象

4、抽象类的构造器存在的意义

为了约定子类的构造器必须和父类匹配

5、一个类如果继承了抽象类，就必须重写这个类的所有抽象方法

abstract都能修饰什么？

类、方法

抽象方法能不能用private修饰？

不能

开发中抽象方法基本上都是public

抽象方法能不能用final修饰？

不能，用final修饰的方法是不能重写的

抽象类能不能用final修饰？

不能，用final修饰的类是不允许被继承的

总结：

1、抽象方法必须是public或者protected（如果是private是不能被子类继承，

子类便无法实现该方法），默认情况下是可以的（默认情况是public）。

2、抽象类是不能被直接实例化，需要依靠子类采用向上转型的方式（多态）

3、抽象类必须有子类，使用extends，一个类只能继承一个抽象类

4、子类(如果不是抽象类)则必须重写抽象类中的所有抽象方法

(如果子类没有实现父类的抽象方法，必须将子类定义为abstract)

接口

比抽象类更高级的抽象抽象类比类更高级的抽象

声明：使用interface关键字，public interface Ch02

JDK1.7之前：接口中只能定义抽象方法，不能有属性，不能有方法

（静态的常量）

JDK8及以后：接口中只能定义抽象方法，不能有属性，可以有默认方法和静态方法

静态常量

JDK7--JDK8：静态方法和默认方法

接口中结构的特点：

接口中的抽象方法默认是public abstract，我们推荐就省略了

接口中的常量默认是public static final，我们推荐就省略了

接口中的结构必须是public

接口可以被实现，实现类

比如说A类 implements 接口，那我们就说A是这个接口的实现类

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

实现接口是可以多实现的，继承只能单继承

开发中，如果一件事情可以通过继承和实现接口来解决问题，优先接口解决

面试题

1、继承抽象类和实现接口的异同。

2、抽象类和接口的区别。

接口存在的意义：

约定（比抽象类更加严格）。

多态的前提条件

1、继承

2、重写方法

3、父类---子类，接口---实现类

面试题：

在Java中只有单继承？

×存在多继承，发生在接口之间

public class A implements B,C,D{}

Java类与类之间只有单继承

面向对象编程

面向接口编程：主要写接口

面向切面编程

栈和队列：
栈和队列是两种操作受限的线性表

受限表现在：
    栈的插入和删除只允许在表的尾端进行（在栈中叫做栈顶），满足FILO
        First In Last Out；
    队列只允许在表位插入元素，在表头删除元素，FIFO
        First In First Out；
    栈与队列的相同点：
    １、都是线性结构
    ２、插入操作都是在表尾进行
    ３、都可以通过循序结构和链式结构实现
    栈与队列的不同点：
    １、队列：先进先出　栈：先进后出

posted @ 2022-07-26 22:01 LJMMJL 阅读(33) 评论(0) 收藏举报

ljmskipper

学习笔记——栈、队列

公告