java模拟学生选课：connection接口

1.List类型
2.Set类型
3.泛型类型
4.LIst与Set的区别

1.List类型
*选择课程（往集合中添加课程）
*删除所选的某门课程（删除集合中的元素）
*查看所选的课程
*修改所选的课程

所用知识点：

List中的三种add方法：
1>添加了元素
2>在某一位置添加元素
3>创建数组，addAll（Arrays.asList(courses）//数组转化为List 添加多个元素
4>addAll(index, Arrays.asList(course)在某一位置添加多个元素

判断List中课程是否存在：
contains—>contains(Object o)如果此列表中包含指定的元素，则返回true,否则返回false
containsALL:只包含多个元素

遍历的三种方法：
1>使用size元素：int size(); 返回列表中的元素个数即get()方法
2>使用迭代器遍历；iterator方法
3>通过for-each遍历

修改：
set方法：set(index, element)
index:要替换的元素的索引
element:要在指定位置存储的元素

删除：remove方法：
1>remove(index):移除列表中指定位置的元素
2>remove(o)：移除指定元素
3>removeAll:创建数组，移除数组包含的所有元素

List接口：

Course类：

`public class Course {
	
	public String id;
	public String name;
	
	public Course(String id, String name) {
		this.id = id;
		this.name = name;
	}
	
	/*
	 * 此类为父类，而在子类中只有无参构造器，父类中已经有一个有参构造器，
	 * 不会自动生成一个无参构造器，则需要构建一个无参构造器
	 */
	public Course() {
		
	}`

@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

	@Override
/*
	 *用contains中遍历则需要加的固定代码
	 */
	public boolean equals(Object obj) {
		if(this == obj)//如果可以直接用==来判定，可直接返回ture
			return true;
		if(obj == null)
			return false;
		if(!(obj instanceof Course))
			return false;
		Course course = (Course)obj;
		
		if(this.name == null) {
			if(course.name == null)
				return true;
			else
				return false;
		}else {
			if(this.name.equals(course.name))
				return true;
			else
				return false;	
		}
		
	}

Student类：

import java.util.HashSet;
import java.util.Set;

public class Student {
	
	public String id;
	public String name;
	public Set<Course> courses;
	
	public Student(String id, String name) {
		this.id = id;
		this.name = name;
		this.courses = new HashSet<Course>();
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (!(obj instanceof Student))
			return false;
		Student other = (Student) obj;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	

}

ListTest类：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

public class ListTest {
	/*
	 * 用于存放备选课程的List
	 */
	public List coursesToSelect;
	
	public ListTest() {
		this.coursesToSelect = new ArrayList();
	}
	
	public void testAdd() {
		Course cr1 = new Course("1","数据结构");
		coursesToSelect.add(cr1);
		Course temp = (Course)coursesToSelect.get(0);
		System.out.println("添加了课程："+temp.id+"."+temp.name);
		
		
		
		Course cr2 = new Course("2", "C语言");
		coursesToSelect.add(0,cr2);
		Course temp2 = (Course)coursesToSelect.get(0);
		/*
		 * 对象存入集合中都变成了Object类型，取出时需要强制类型转换
		 */
		System.out.println("添加了课程："+temp2.id+"."+temp2.name);
		
		//Course cr3 = new Course("3","test");
		//coursesToSelect.add(4,cr3);会抛出下标越界异常
		
		
		
		coursesToSelect.add(cr1);
		Course temp0 = (Course)coursesToSelect.get(2);
		System.out.println("添加了课程："+temp.id+"."+temp.name);
		
		
		
		Course[] course = {new Course("3", "离散数学"),new Course("4","汇编语言")};
		coursesToSelect.addAll(Arrays.asList(course));
		Course temp3 = (Course) coursesToSelect.get(3);
		Course temp4 = (Course) coursesToSelect.get(4);
		System.out.println("添加了两门课程："+temp3.id+":"+temp3.name+";"+temp4.id+":"+temp4.name);
		
		
		
		Course[] course2 = {new Course("5", "高等数学"),new Course("6","大学英语")};
		coursesToSelect.addAll(2,Arrays.asList(course2));
		Course temp5 = (Course)coursesToSelect.get(2);
		Course temp6 = (Course)coursesToSelect.get(3);
		System.out.println("添加了两门课程："+temp5.id+":"+temp5.name+";"+temp6.id+":"+temp6.name);
		
	}
	
	public void testGet() {
		System.out.println("有如下课程待选：");
		int size = coursesToSelect.size();
		for(int i = 0; i < size; i++) {
			Course cr = (Course)coursesToSelect.get(i);
			System.out.println("课程："+cr.id+":"+cr.name);
		}
	}
	
	public void testIterator() {
		System.out.println("有如下课程待选：通过迭代器遍历");
		Iterator it = coursesToSelect.iterator();
		while(it.hasNext()) {
			Course cr = (Course) it.next();
			System.out.println("课程："+cr.id+":"+cr.name);
		}
	}
	
	public void testForeach() {
		System.out.println("有如下课程待选：通过Foreach遍历");
		for(Object obj : coursesToSelect) {
			Course cr = (Course)obj;
			System.out.println("课程："+cr.id+":"+cr.name);
		}
	}
	
	public void testModify() {
		coursesToSelect.set(4,new Course("7", "毛概"));
	}
	
	
	public void testRemove() {
		//Course cr = (Course) coursesToSelect.get(4);
		//System.out.println("我是课程："+cr.id+":"+cr.name+",我即将被删除");
		//coursesToSelect.remove(4);
		Course[] courses = {(Course)coursesToSelect.get(4),(Course)coursesToSelect.get(5)};
		coursesToSelect.removeAll(Arrays.asList(courses));
		System.out.println("成功删除课程");
		testForeach();
	}
	
	
	public static void main(String[] args) {
		ListTest lt = new ListTest();
		lt.testAdd();
		lt.testGet();
		lt.testIterator();
		lt.testForeach();
		lt.testModify();
		lt.testForeach();
		lt.testRemove();
		
	}

}

运行结果：
添加了课程：1.数据结构
添加了课程：2.C语言
添加了课程：1.数据结构
添加了两门课程：3:离散数学;4:汇编语言
添加了两门课程：5:高等数学;6:大学英语
有如下课程待选：
课程：2:C语言
课程：1:数据结构
课程：5:高等数学
课程：6:大学英语
课程：1:数据结构
课程：3:离散数学
课程：4:汇编语言
有如下课程待选：通过迭代器遍历
课程：2:C语言
课程：1:数据结构
课程：5:高等数学
课程：6:大学英语
课程：1:数据结构
课程：3:离散数学
课程：4:汇编语言
有如下课程待选：通过Foreach遍历
课程：2:C语言
课程：1:数据结构
课程：5:高等数学
课程：6:大学英语
课程：1:数据结构
课程：3:离散数学
课程：4:汇编语言
有如下课程待选：通过Foreach遍历
课程：2:C语言
课程：1:数据结构
课程：5:高等数学
课程：6:大学英语
课程：7:毛概
课程：3:离散数学
课程：4:汇编语言
成功删除课程
有如下课程待选：通过Foreach遍历
课程：2:C语言
课程：1:数据结构
课程：5:高等数学
课程：6:大学英语
课程：4:汇编语言

2.*测试泛型类型
1>泛型类型添加
2>泛型类型遍历
3>泛型集合可以添加泛型的子类型的对象实例
4>泛型类型不能使用基本数据类型

测试类TestGeneric：

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

public class TestGeneric {
	
	public List<Course> coursesToSelect;
	
	public TestGeneric() {
		this.coursesToSelect = new ArrayList<Course>();
	}
	/*
	 * 测试泛型类型添加
	 */
	public void testAdd() {
		Course cr = new Course("1","java基础");
		coursesToSelect.add(cr);
		
		Course cr2 = new Course("2","C#");
		coursesToSelect.add(cr2);
		
		//泛型集合中，不能添加泛型类型及其子类型以外的对象，否则会报错
		//Course cr3 = new Course("能否添加其他东西");
	}
	/*
	 * 测试泛型类型的遍历
	 */
	public void testForeach() {
		for(Course cr : coursesToSelect) {
			System.out.println("课程"+cr.id+":"+cr.name);
		}
	}
	
	/*
	 * 泛型集合可以添加泛型的子类型的对象实例
	 */
	public void testChild() {
		childCourse cr = new childCourse();
		cr.id = "3";
		cr.name = "我是泛型的子类型实例";
		coursesToSelect.add(cr);
		testForeach();
	}
	
	/*
	 * 泛型类型不能使用基本数据类型
	 */
	public void testBasicType() {
		List<Integer> list = new ArrayList<Integer>();
		list.add(1);
		System.out.println("基本数据类型必须使用包装类"+list.get(0));
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		TestGeneric te = new TestGeneric();
		te.testAdd();
		te.testForeach();
		te.testChild();
		te.testBasicType();
		}

}

添加的Course类的子类childCourse：

public class childCourse extends Course{

}

运行结果：

课程1:java基础
课程2:C#
课程1:java基础
课程2:C#
课程3:我是泛型的子类型实例
基本数据类型必须使用包装类1

3.Set接口：
*提供备选课程
*创建学生对象，并给该学生添加三门课程（添加在学生的courses—Set类型的属性中）
*显示备选课程
*循环三次，每次输入课程ID
*往学生的courses属性中添加与输入的ID匹配的课程
*输出学生选择的课程

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

public class SetTest {
	
	public List<Course> coursesToSelect;
	private Scanner console;
	
	public SetTest() {
		this.coursesToSelect = new ArrayList<Course>();
		console = new Scanner(System.in);
	}
	
	public void testAdd() {
		Course cr1 = new Course("1","数据结构");
		coursesToSelect.add(cr1);
		Course temp = (Course)coursesToSelect.get(0);
		
		
		Course cr2 = new Course("2", "C语言");
		coursesToSelect.add(0,cr2);
		Course temp2 = (Course)coursesToSelect.get(0);
		
		
		
		Course[] course = {new Course("3", "离散数学"),new Course("4","汇编语言")};
		coursesToSelect.addAll(Arrays.asList(course));
		Course temp3 = (Course) coursesToSelect.get(2);
		Course temp4 = (Course) coursesToSelect.get(3);
		
		
		Course[] course2 = {new Course("5", "高等数学"),new Course("6","大学英语")};
		coursesToSelect.addAll(2,Arrays.asList(course2));
		Course temp5 = (Course)coursesToSelect.get(2);
		Course temp6 = (Course)coursesToSelect.get(3);
		
	}
	
	public void testForeach() {
		System.out.println("有如下课程待选：通过Foreach遍历");
		for(Object obj : coursesToSelect) {
			Course cr = (Course)obj;
			System.out.println("课程："+cr.id+":"+cr.name);
		}
	}
	

public void testListContains() {
		Course course = new Course();
		course = coursesToSelect.get(0);
		System.out.println("取得课程"+course.name);
		System.out.println("是否包含备选课程："+course.name+","+coursesToSelect.contains(course));
	
		System.out.println("请输入课程名字：");
		String name = console.next();
		Course course2 = new Course();
		course2.name = name;
		System.out.println("新创建课程："+course2.name);
		System.out.println("是否包含备选课程："+course2.name+","+coursesToSelect.contains(course2));
		
		//此时为输入课程名字，再遍历
		//第一个是true,第二个是false,虽然他们用相同的ID和相同的name，但是对象不同


   /*
		 * indexOf方法返回值是列表中的某元素的第一个的索引位置
		 * lastindexOf方法返回值死列表中的某元素的最后一个的索引位置
		 * 若列表中无某元素，则返回-1
		 */
		if(coursesToSelect.contains(course2))
			System.out.println("课程："+course2.name+"的索引位置为："+
		    coursesToSelect.indexOf(course2));
	}
//创建学生对象并选课
	public void creatStudentAndSelectCourse() {
		student = new Student("1","小明");
		System.out.println("欢迎学生："+student.name+"选课！");
		
		Scanner console = new Scanner(System.in);
		
		
		for(int i = 0; i < 3; i++) {
			System.out.println("请输入课程ID");
			String courseId = console.next();
			for(Course cr : coursesToSelect) {
				if(cr.id.equals(courseId)) {
					student.courses.add(cr);
				}
			}
		}
	}
	//测试Set的contains方法
	public void testSetContains() {
		System.out.println("请输入课程名字：");
		String name = console.next();
		Course course2 = new Course();
		course2.name = name;
		System.out.println("新创建课程："+course2.name);
		System.out.println("是否包含备选课程："+course2.name+","+student.courses.contains(course2));
		
	}



	public static void main(String[] args) {
		// TODO Auto-generated method stub
		SetTest st = new SetTest();
		st.testAdd();
		st.testForeach();
		st.testListContains();
		
		Student student = new Student("1","小明");
		System.out.println("欢迎学生："+student.name+"选课！");
		
		Scanner console = new Scanner(System.in);
		
		
		for(int i = 0; i < 3; i++) {
			System.out.println("请输入课程ID");
			String courseId = console.next();
			for(Course cr : st.coursesToSelect) {
				if(cr.id.equals(courseId)) {
					student.courses.add(cr);
				}
			}
		}
		st.testForeachForSet(student);
		
	}
	public void testForeachForSet(Student student) {
		for(Course cr: student.courses) {
			System.out.println("选择了课程："+cr.id+":"+cr.name);
		}
	}

}

4.List与Set的区别：
List遍历时可使用for each方法，iterator方法，get方法
Set遍历时不可食用get()方法，因为Set中的元素是无序的不可重复的