12.22 Java基础17

• 作业回顾

3. 根据如下需求编写对应代码
1）定义图书（Book）的javabean类，其中包括图书编号、图书名称、单价三个属性
2）从控制台接收不少于3本图书的信息，将每本图书信息封装到Book的类中，并将每本图书的Book对象 保存在图书编号为key的map集合中
3）一次性将接收到所有图书信息打印控制台

我的答案：

import java.math.BigDecimal;

/**
 * 
 * @author Administrator
 *3. 根据如下需求编写对应代码
1）定义图书（Book）的javabean类，其中包括图书编号、图书名称、单价三个属性
2）从控制台接收不少于3本图书的信息，将每本图书信息封装到Book的类中，并将每本图书的Book对象 保存在图书编号为key的map集合中
3）一次性将接收到所有图书信息打印控制台
 */
public class Book {
    private String no;
    private String name;
    private BigDecimal price;
    
    public Book() {
        // TODO Auto-generated constructor stub
    }

    public Book(String no, String name, BigDecimal price) {
        super();
        this.no = no;
        this.name = name;
        this.price = price;
    }

    public String getNo() {
        return no;
    }

    public void setNo(String no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

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

    public BigDecimal getPrice() {
        return price;
    }

    public void setPrice(BigDecimal price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book [no=" + no + ", name=" + name + ", price=" + price + "]";
    }
}

 

import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

/**
 * 
 * @author Administrator
 *3. 根据如下需求编写对应代码
1）定义图书（Book）的javabean类，其中包括图书编号、图书名称、单价三个属性
2）从控制台接收不少于3本图书的信息，将每本图书信息封装到Book的类中，
并将每本图书的Book对象 保存在图书编号为key的map集合中
3）一次性将接收到所有图书信息打印控制台
 */
public class BookTest<T> {
    private Scanner scanner = new Scanner(System.in);
    private Map<T, Book> map = new HashMap<T, Book>();
/**
 * 接收图书的方法
 */
    public void add() {
        System.out.println("请输入图书编号");
        String no = scanner.next();
        while (map.containsKey(no)) {
            System.out.println("不能重复添加");
            System.out.println("请输入图书编号");
            no = scanner.next();
        }
        System.out.println("请输入图书名称");
        String name = scanner.next();
        System.out.println("请输入图书单价");
        BigDecimal price = scanner.nextBigDecimal();
        Book b = new Book(no, name, price);
        map.put((T) no, b);
    }

    public void init() {
        boolean isContinue = true;
        int time = 0;
        System.out.println("欢迎使用图书信息系统");
        while (isContinue) {
            add();
            time++;
            if (time > 3) {
                System.out.println("请确认是否继续添加（y/n)");
                String result = scanner.next();
                if (result.equalsIgnoreCase("y")) {
                    isContinue = true;
                } else {
                    isContinue = false;
                }
            }
        }
        System.out.println("已添加图书信息如下：" + map);
    }

    public static void main(String[] args) {
        BookTest bt = new BookTest();
        bt.init();
    }
}

老师的解法：

public class Book {
    private String name;
    private Integer id;
    private Integer price;
    
    @Override
    public String toString() {
        return "Book [name=" + name + ", id=" + id + ", price=" + price + "]";
    }
    public Integer getPrice() {
        return price;
    }
    public void setPrice(Integer price) {
        this.price = price;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
}

 

import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

public class bookStore<T> {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Map<Integer, Book> maps = new HashMap<>();
        System.out.println("欢迎使用图书管理系统");
        boolean isContinue = true;
        while (isContinue) {
            Book book = new Book();
            System.out.println("输入图书名字");
            String name = scanner.next();
            System.out.println("输入图书价格");
            Integer price = scanner.nextInt();
            System.out.println("输入图书编号");
            Integer id = scanner.nextInt();
            book.setId(id);
            book.setName(name);
            book.setPrice(price);
            maps.put(id, book);
            if (maps.size() >= 3) {
                System.out.println("是否继续,y/n");
                String result = scanner.next();
                if (result.equals("y")) {
                    isContinue = true;
                } else {
                    isContinue = false;
                }
            }
        }
        
        Collection<Book> list= maps.values();
        
        list.forEach(i->{
            System.out.println(i);
        });
        scanner.close();
    }
}

相比之下，我的方法可能更杂一些，不能为了封装而封装。。毕竟这题可封装的方法少。此外，我没有想到输入次数和HashMap.size()是一样的，加了计数器。。

• 泛型
• 练习

1.泛型练习
    车、汽油、汽车的行为
    
    奇瑞QQ   92
    奔驰E    95
    劳斯莱斯 98
    奇瑞QQ加油（加92号）
    开（92）每公里消耗92号，N升 
    接口 车
    实体类 汽油 
    三个类 奇瑞QQ、奔驰E、劳斯莱斯 
    

代码：

public class Gasoline92 {
    private String name="92号汽油";

    public String getName() {
        return name;
    }

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

public class Gasoline95 {
    private String name="95号汽油";

    public String getName() {
        return name;
    }

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

public class Gasoline98 {
    private String name="98号汽油";

    public String getName() {
        return name;
    }

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

 

public interface Car<T> {
    public void jiayou(T t);
    public void drive(T t);
}

 

import com.ywz.practice.one.entity.Gasoline95;
import com.ywz.practice.one.inte.Car;

public class Benz implements Car<Gasoline95> {

    public void jiayou(Gasoline95 t) {
        // TODO Auto-generated method stub
        System.out.println("奔驰加的是" + t.getName());
    }

    public void drive(Gasoline95 t) {
        // TODO Auto-generated method stub
        System.out.println("奔驰消耗的是" + t.getName());
    }
}

2.泛型练习
    动物、食物、行为
    猫    鱼
    狗    肉  
    猫 吃 鱼
    猫 抓 老鼠
    狗 吃 肉
    狗 抓 兔子

相关代码：（这题没想到泛型可以用多个参数。。）

public class Beef {
    private String name="牛肉";

    public String getName() {
        return name;
    }

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

 

public class Fish {
    private String name="鱼";

    public String getName() {
        return name;
    }

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

 

public class Mouse {
    private String name="老鼠";

    public String getName() {
        return name;
    }

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

 

public class Rabbit {
    private String name="兔子";

    public String getName() {
        return name;
    }

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

}

 

public interface Pet<T,T2> {//泛型可以设置不止一个
    
    public void eat(T t);
    public void catchs(T2 t);
}

import com.ywz.practice.two.entity.Fish;
import com.ywz.practice.two.entity.Mouse;
import com.ywz.practice.two.inte.Pet;

public class Cat implements Pet<Fish,Mouse>{

    public void eat(Fish t) {
        // TODO Auto-generated method stub
        System.out.println("猫吃"+t.getName());    
    }
    
    public void catchs(Mouse t) {
        // TODO Auto-generated method stub
        System.out.println("猫抓"+t.getName());
    }
}

 

import com.ywz.practice.two.entity.Beef;
import com.ywz.practice.two.entity.Rabbit;
import com.ywz.practice.two.inte.Pet;

public class Dog implements Pet<Beef,Rabbit>{

    public void eat(Beef t) {
        // TODO Auto-generated method stub
        System.out.println("狗吃"+t.getName());
        
    }

    public void catchs(Rabbit t) {
        // TODO Auto-generated method stub
        System.out.println("狗抓"+t.getName());
    }
}

• 通配符

类型通配符一般就是一个“?”,代替具体的参数类型。

切记是实参而不是形参。

 

类型通配符上限语法

接口名/类名<T   extends    实参类型 >

方法名(  类名<?  extends  实参类型>  变量名)

该泛型的实参类型，只能是它自已或它的子类类型

     JDK：public boolean addAll(Collection<? extends E> c)

类型通配符下限语法

接口名/类名<T  super    实参类型 >

方法名(  类名<?  super  实参类型>  变量名)

该泛型的实参类型，只能是它自已或它的父类类型

      JDK：public TreeSet(Comparator<? super E> comparator) 

 

相关练习：把之前的第二题加上通配符、抽象类进行优化
    主要是优化动物的方法，要不然每次实现动物的时候都要重写一遍方法，并实现方法的内容。

public class Food {

    private String name;

    public String getName() {
        return name;
    }

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

 

public class Mouse extends Food{
    
    public Mouse(){
        setName("老鼠");
    }
}

 

public class Beef extends Food{
    
    public Beef() {
        setName("牛肉");
    }
}

 

public class Rabbit extends Food{
    
    public Rabbit() {
        setName("兔子");
    }
}

 

public class Fish extends Food {
    
    public Fish() {
        setName("鱼");
    }
}

 

/**
 * pet抽象类
 * @author Administrator
 *
 * @param <T>
 * @param <T2>
 */
public abstract class AbPet<T extends Food, T2 extends Food> {

    private String name;

    public String getName() {
        return name;
    }

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

    public void eat(T t) {
        System.out.println(name + "吃" + t.getName());
    };

    public void catchs(T2 t2) {
        System.out.println(name + "捕获" + t2.getName());
    };

    public void play(T2 t2) {
        System.out.println(name + "戏耍" + t2.getName());
    };
}

 

public class Cat extends AbPet<Fish,Mouse>{
    public Cat() {
        setName("猫");
    }
}

 

public class Dog extends AbPet<Beef,Rabbit>{
    public Dog() {
        setName("狗");
    }
}

 

public class Maotouying extends AbPet<Mouse, Mouse> {

    public Maotouying() {
        setName("猫头鹰");
    }

    public void fly() {
        System.out.println(getName() + "会飞");
    }
}

 

public class MainT {

    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat(new Fish());
        cat.catchs(new Mouse());

        Maotouying mty = new Maotouying();
        mty.fly();
        mty.eat(new Mouse());
    }
}

 

• Collections工具类

 

方法	功能
static <T extends Comparable<? super T>> void sort(List<T> list)	根据元素的自然顺序对指定列表按升序进行排序
static <T> void  sort(List<T> list, Comparator<? super T> c)	根据指定比较器产生的顺序对指定列表进行排序

相关代码：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class FCollections {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(4);
        list.add(2);
        list.add(111);

        // 正序
        Collections.sort(list);

        // 倒序
        Collections.reverse(list);
        list.forEach(i -> {
            System.out.println(i);
        });

        List<GBook> list2 = new ArrayList<>();
        list2.add(new GBook("红楼梦", 20));
        list2.add(new GBook("三国演义", 40));
        list2.add(new GBook("游文智自传", 50));
        list2.add(new GBook("思想品德", 10));
        Collections.sort(list2);
        Collections.reverse(list2);

        List<GBook> list3 = new ArrayList<>();
        list3.add(new GBook());
        list3.add(new GBook());
        list3.add(new GBook());
        list3.add(new GBook());

        // 复制(不好用，得右边的长度大于等于左边)
        Collections.copy(list3, list2);

        list3.forEach(i -> {
            System.out.println(i);
        });

    }
}

• File类

文件是存储数据的集合，文件夹是存文件的集合。

JDK的java.io包，其中包含一系列对文件和目录的属性进行操作，对文件进行读写操作的类。

在程序中一个File类对象可以代表一个文件或目录。

注意：File对象并不能直接对文件内容进行读/写操作，只能查看文件的属性。

构 造 方 法	说    明
File(String pathname)	指定文件（或目录）名和路径创建文件对象

File 类里个属性public static final String separator：得到与系统相关的默认分隔符字符。也就是说，创建文件对象可以这样写

File file =new File("d:"+File.separator+"Test.txt");  file.createNewFile();

在Java中“\”符号表示转意，因此如果使用”\”作为路径分割符，则实际需要编写“\\”，当然一个更好的替代方法是使用Unix系统中常用的”/”作为路径分割，则不需要转义。

 

方 法 原 型	说    明
String getName()	获得文件的名称
String getAbsolutePath()	获得文件的绝对路径
long length()	获得文件的长度（字节数）
public long lastModified()	返回此抽象路径名表示的文件上次修改的时间

 

方 法 原 型	说    明
boolean createNewFile() throws IOException	创建新文件，创建成功返回true，否则返回false，若文件不存 则创建，如果文件存在则不创建
public boolean mkdir()	创建由此抽象路径名命名的目录。(只能创建单层)
public boolean mkdirs()	创建由此抽象路径名命名的目录，（可以创建多层）
boolean delete()	删除文件，删除成功返回true，否则返回false，如果文件夹里有文件则创建失败返回false

注意：

不能在创建文件时创建文件夹，也不能在创建文件夹时创建文件；

当删除多层文件夹时，直接删除最外层，返回false，要先从里向外删除。

方 法 原 型	说    明
boolean exists()	判断文件是否存在，存在返回true，否则返回false
boolean isFile()	判断是否为文件，是文件返回true，否则返回false
boolean isDirectory()	判断是否为目录，是目录返回true，否则返回false

 

方 法 原 型	说    明
public boolean renameTo(File dest)	重命名由此抽象路径名表示的文件。

 

方 法 原 型	说    明
public long getTotalSpace()	盘符的总容量
public long getFreeSpace()	剩余空间
public long getUsableSpace()	可用空间

 

方 法 原 型	说    明
public String[] list()	返回一个字符串数组，命名由此抽象路径名表示的目录中的文件和目录 如果访问的是c盘下的系统级文件夹，会报空指针 如果访问的是文件夹是空的，那返回的数组长度是0
public  File[]   listFiles()	返回文件夹内的子文件与子文件夹的数组

 

方 法 原 型	说    明
public File[] listFiles(FileFilter filter)	文件过滤器
public String[] listFiles(FilenameFilter filter)	文件名过滤器

 

代码待附上

感想：老师讲的有些快。。思路跟得上，只是代码要多试试。

19:21:12 2021-12-22