Java面向对象第九天(--泛型--图书管理系统--)

1.泛型: 

   定义: 标识集合中保存的元素.

   格式: 1.<泛型>;      格式 : 2.  ? extends E ;

   好处:  1.操作数据更加安全,规范集合中能保存的数据;

            2.可以避免向下强制转型的麻烦,

             3.将运行时的错误转到编译时报错;

    注意: 

        1.类上声明的泛型,会在创建对象的时候,被赋值真正的类型; 一个类可以声明不止一个泛型; public class Worker<Z>{}

        2.如果你在方法中声明了泛型,该泛型会在方法被调用的时候, 进行复制泛型; public<W> void fun(W w){};

        3.静态方法中不能使用类上声明的泛型,静态是用类调用,可能没有对象的产生, 如果想使用泛型,需要自己单独声明

       public static <a> void sayHi<a a >{ };

 例题;

1. 泛型的正向遍历和逆向遍历 

ArrayList<String> list =new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
//遍历集合,
 ListIterator iterator = list. ListIterator();
  while(iterator.hasNext()){
        String next = iterator.next();
         System.out.println(next);

}
//逆向遍历,
  while (iterator.hasPerious){
   //获取钱一个元素,要逆向遍历之前必须先要有正向,因为要把内部指针正向移动到最下面,
         iterator previous = iterator.previous();
          System.out.println(previous);
}

  创建Worker类和Student类;

public class Worker<Z> {
	//成员变量;
	private Z z ;
	//成员方法set get
	
	public void setZ(Z z) {
		 this.z=z;
	}
	
	public Z getZ() {
		return this.z;
	}
   
	//一个类中可以几个泛型;
	//如果你在方法中声明了新的泛型,该泛型会在方法被调用的时候 赋值泛型;
	//需要在方法中声明出来;
	public<W>  void  fun(W w) {
		 System.out.println(w);
	}
	
	//能不能使用泛型 静态使用类名进行去掉,可能不能被使用; 
	//静态方法中,不能使用类声明上的泛型;使用类名调用方法的时候,没有对象的创建,
	//Z泛型还没有被赋值;
	//使用泛型的时候可以单独声明一下;在Static 后面;
	public static<a> void sayHi(a a ) {
		
	}	
     public void work() {
    	      
    	      System.out.println(z);
    	     System.out.println("我在工作,不扯犊子");
    	     
     }
}

package com.lanou3g.bean;
//继承不用重写父类方法;
public class Student extends Person {
       //构造方法没有被继承,要自己写出来;
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Student(int age, String name) {
		super(age, name);
		// TODO Auto-generated constructor stub
	}
    
}

2.创建一个集合保存三个学生的集合要用到泛型;

ArrayList<Student> list = new ArrayList<>();
list.add(new Student(16,"桐人"));
list.add(new Student(16,"瑟利亚"));
list.add(new Student(16,"结衣"));
//从集合中取出一个元素;
Student student= (Student) list.get(0);
System.out .println(student.getAge()+student.getName());
//如果不加泛型,元素类型你可以强转,而且强转后也不会报错,但是编译时候不会报错,
 //我现在把集合中的一个元素强转成工人类;
Worker worker = (Worker)list.get(1);

假如我加上泛型,在编译过程中就会报错;
Worker worker1 = (Worker)list.get(0);//会报错

3.泛型接口

interface InterA<M>{
    public abstract void fun();
}
//接口泛型在实现类里面会有体现
  class InterAImpl implements Inter<String>{
        public void fun(){
         };
}

4.泛型中删除

//如果;有b就删除b;
ArrayList<String>list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
//集合的长度用size();
for(int i=0;i<list.size();i++){
      String num = list.get(i);
       if(num.equals("b")){
          list.remove(i--);
         //移除index为i的元素;  
  }
}

迭代器方法删除, 

ArrayList<String> list = new ArrayList<>();
		list.add("a");
		list.add("b");
		list.add("b");
		list.add("c");
		list.add("d");
Interator<String>iterator = list.iterator();
 while(interator.hasNext()){
      String next = iterator.next();
       if(next.equals("b")){
     //迭代器中需要使用迭代器的放方法;避免出现修改异常;
 }

}
System.out.pritln(next)

5.迭代器中排序

创建一个集合保存学生,按照年龄进行排序,

ArrayList<Student> student = new ArrayList<>();
list.add(Student(12,"桐人"));
list.add(Student(11,"瑟利亚"));
list.add(Student(10,"结衣"));
for (int i = 0; i < list.size() - 1; i++) {
			for (int j = 0; j < list.size() - 1 - i; j++) {
				// 找出j和j+1的学生
				if (list.get(j).getAge() > list.get(j + 1).getAge()) {					
					//直接使用工具类的方法
					Collections.swap(list, j, j+1);					
				/* // 交换的是学生;
					Student temp = list.get(j);
					//set 交换集合中的对象位置;
					list.set(j, list.get(j + 1));
					list.set(j + 1, temp);      */

				}
			}

		}
System.out.println(list);

2.图书馆题目练习

要求:1.打印所有类型图书(遍历集合)

       2.打印动作类图书(测试时 每个种类添加三本书) 

       3. 打印科幻类图书  

       4.打印爱情类图书(按类型打印不同的图书信息 1.按照类型找到角标  2.按照角标找对应的集合 3.遍历集合)

       5 .添加图书(按照不同种类添加)去重

       6.通过图书种类和书名,将这本书删掉;

    

//提供书类;
public class Book{
   private String bookName;
   private String bookAuthor;
   private String bookType;
   //有参无参构造方法;
   public Book(){
   super();
}
   public Book(String bookName,String bookAuthor,String bookType){
   super();
   this.bookName = bookName;
   this.bookAuthor = bookAuthor;
   this.bookType = bookType;
}
 //  提供set/get方法;
 public String getBookName(){
   return bookName;
}

public void setBookName(String bookName){
    this.bookName = bookName;
}

public String getBookAuthor(){
       return bookAuthor;
}

public String setBookAuthor( string bookAuthor){
     this.bookAuthor = bookAuthor;
}
 
public String getBookType() {
		return bookType;
	}

	public void setBookType(String bookType) {
		this.bookType = bookType;
	}

//重新书写父类的toString 方法;
public String toString(){
 return "Book[bookName="+bookname+",bookAuther="+bookAuther+",bookType ="+bookType+"]"; 
}
  //重写父类的equals方法;
  public boolean equals(Object obj){
  Book book = (Book)obj;
 //重写去重的规则;
   return this.bookName.equals(book.getBookName();)&&this.bookType.equals(book.getBookType())&&this.bookAuthor.equals(book.getBookAuthor());
 }
}

 //提供图书馆类

public class Library {
	private String libraryName;
	// 声明保存书的小集合的容器
	// (在构造方法中往大集合里面添加小集合 使用循环往大集合中添加小集合;)
	private ArrayList list;

	public Library(String libraryName) {
		super();
		init();
		this.libraryName = libraryName;
	}

	public Library() {
		super();
		init();

	}

	// 集合初始化的方法;
	public void init() {
		// 初始化大数组 2.添加小集合;必须初始化不然会抱错;
		this.list = new ArrayList();
		// 添加小集合到大集合里面;
		for (int i = 0; i < 3; i++) {
			ArrayList l = new ArrayList<>();
			// 添加大集合;
			this.list.add(l);
		}
	}
public String getLibraryName() {
		return libraryName;
	}

	public void setLibraryName(String libraryName) {
		this.libraryName = libraryName;
	}

//加入一个方法添加书籍;要按照书的类型进行填加;

 1.按照书的类型倒找相应的角标;
public int getIndexByBookType(Book book){
//声明一个角标index 
 int index = -1;//传了的类型没有;
 switch(book.getBookType){ //获得传入数的类型
   case "动作类":
     index = 0;
      break:
   case "爱情类";
      index = 1;
       break;
   case "科幻类"
       index = 2;
        break;
    default:
        break;

  }
  //返回值 
   return index;
} 

//封装一个按照类型对象的集合;
 public ArrayList getListByBook(Book book){
   //找角标.同过传入book找到相应的角标
  int index = getIndexByBookType(book);
//判断一下返回的角标
 if(index ==-1){
     System.out.println("这个类型添加不了")
  return null;
 }
// 用角标找到相应的小集合
  Object object = this.list.get(index);
 //转成ArrayList 
 ArrayList l = (ArrayList) object;
   return l;
}

//按类型的不同打印图书的信息;
public void PrintByType(Book book){
  ArrayList books = getListByBook(book);
   if(books = null){
      System.out.println("没有该类型")
      }
     //遍历打印这个集合
  Iterator iterator = books.iterator();
        while(iterator.hasNext()){
            Book next =(Book)iterator.next();
            System.out.println(next);
    }
 }

//遍历打印所有图书,遍历大集合;

public void printlnList(){
  for(Object temp: this.list){
        ArrayList temp1 = (Arraylist)temp;
  // 然后遍历小集合;
  for(Object obj:temp1){
       Book book = (Book)obj;
        System.out.println(book);
     }
  }
}

// 开始往集合中添加书籍,封装一个方法;

 public void addNook(Book book){
  //声明一个不同类型书的集合;返回是不同类型
ArrayList books = getListByBook(book);
  if(books == null){
    System.out.println("添加不了"+book.getBookName());
       return;
 }
 //添加去重, 1.重写equals方法;
 //   2. 使用包含关系进行添加,
  if(!books.contains(book)){
       books.add(book);
  }else{
      System.out.println("该书重复了"+book.getBookName());
  }

}

//创建一个测试类进行测

public class Test {
	public static void main(String[] args) {
		Library library = new Library("蓝鸥图书馆");
		System.out.println(library.getLibraryName());
		library.addBook(new Book("学习Java91难", "桐人", "爱情类"));
		library.addBook(new Book("双排Java91难", "游", "动作类"));
		library.addBook(new Book("学习Java之升仙之旅", "三少爷", "科幻类"));
		library.addBook(new Book("学习Java之升仙之旅", "三少爷", "科幻类"));
		library.addBook(new Book("学习Java之升仙之旅", "三少爷", "学系类"));
		// 打印全部;
		library.printList();
		System.out.println("-----------");
		// 根据类型打印;
		// 修改按类型打印的
		Book book = new Book();
		book.setBookType("动作类");
		library.printByType(book);

	}

}