Java面向对象第九天(--泛型--图书管理系统--)
1.泛型:
定义: 标识集合中保存的元素.
格式: 1.<泛型>; 格式 : 2. ? extends E ;
好处: 1.操作数据更加安全,规范集合中能保存的数据;
2.可以避免向下强制转型的麻烦,
3.将运行时的错误转到编译时报错;
注意:
1.类上声明的泛型,会在创建对象的时候,被赋值真正的类型; 一个类可以声明不止一个泛型; public class Worker
2.如果你在方法中声明了泛型,该泛型会在方法被调用的时候, 进行复制泛型; public
3.静态方法中不能使用类上声明的泛型,静态是用类调用,可能没有对象的产生, 如果想使用泛型,需要自己单独声明
public static void sayHi{ };
例题;
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 {
//成员变量;
private Z z ;
//成员方法set get
public void setZ(Z z) {
this.z=z;
}
public Z getZ() {
return this.z;
}
//一个类中可以几个泛型;
//如果你在方法中声明了新的泛型,该泛型会在方法被调用的时候 赋值泛型;
//需要在方法中声明出来;
public void fun(W w) {
System.out.println(w);
}
//能不能使用泛型 静态使用类名进行去掉,可能不能被使用;
//静态方法中,不能使用类声明上的泛型;使用类名调用方法的时候,没有对象的创建,
//Z泛型还没有被赋值;
//使用泛型的时候可以单独声明一下;在Static 后面;
public static 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
}
}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{
public abstract void fun();
}
//接口泛型在实现类里面会有体现
class InterAImpl implements Inter{
public void fun(){
};
}
4.泛型中删除
//如果;有b就删除b;
ArrayListlist = 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 ArrayList list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("b");
list.add("c");
list.add("d");
Interatoriterator = list.iterator();
while(interator.hasNext()){
String next = iterator.next();
if(next.equals("b")){
//迭代器中需要使用迭代器的放方法;避免出现修改异常;
}
}
System.out.pritln(next) 5.迭代器中排序
创建一个集合保存学生,按照年龄进行排序,
ArrayList 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);
}
}