java学习第三周总结

/*
从生活中映射USB接口
	interface USB
		规定USB设备必须完成的方法
		void connect();

鼠标类 implements USB 
	鼠标是一个USB设备，必须完成connect方法
键盘类 implements USB
	键盘是一个USB设备，必须完成connect方法
 */
/**
 * USB接口
 * @author Anonymous
 *
 */
interface USB {
	/**
	 * 要求所有的USB设备，必须完成的方法，告知USB接口连接之后完成的
	 * 功能是什么
	 */
	void connect();
}

/**
 * 鼠标类，遵从USB接口，实现connect方法
 * 
 * @author Anonymous
 */
class Mouse implements USB {
	@Override
	public void connect() {
		System.out.println("鼠标连接USB接口，控制光标");
	}
}

/**
 * Logi类，继承Mouse鼠标类
 * 		1. 鼠标设备
 * 		2. Logi间接遵从USB接口，是一个USB设备
 * @author Anonymous
 *
 */
class Logi extends Mouse {
	@Override
	public void connect() {
		System.out.println("Logi Master 2S");
	}
}

/**
 * 键盘类，遵从USB接口，实现connect方法
 *
 * @author Anonymous
 */
class Keyboard implements USB {
	@Override
	public void connect() {
		System.out.println("键盘连接USB接口，输入设备");
	}
}

/**
 * IKBC继承Keyboard类
 * 		1. 键盘设备
 * 		2. 间接遵从USB接口，也是一个USB设备
 * @author Anonymous
 *
 */
class IKBC extends Keyboard {
	@Override
	public void connect() {
		System.out.println("IKBC C87 静音红轴");
	}
}

/**
 * PC电脑类，使用USB接口，这里需要通过USB接口连接一个USB设备
 * 
 * @author Anonymous
 */
class PC {
	/**
	 * 电脑类连接USB接口连接方法，这里需要的是一个USB设备
	 * 
	 * @param usb USB接口对应的设备
	 */
	public void usbConnect(USB usb) {
		// usb设备执行connect方法
		usb.connect();
	}
}

public class Demo1 {
	public static void main(String[] args) {
		
		// 电脑中有一个方法是使用USB接口连接USB设备
		PC pc = new PC();
		
		// 鼠标和键盘都是USB设备
		Mouse mouse = new Mouse();
		Keyboard keyboard = new Keyboard();
		
		// 电脑需要通过USB接口连接USB设备，mouse鼠标就是USB设备
		pc.usbConnect(mouse);
		// keyboard键盘也是USB设备
		pc.usbConnect(keyboard);
		
		// 传入一个Logi类对象
		pc.usbConnect(new Logi());
		// 传入一个IKBC类对象
		pc.usbConnect(new IKBC());
	}
}

/*
动物园:
	所有的动物都可以看做是一个Animal类
狗类
	Dog
熊猫类
	Panda
老虎类
	Tiger

方法:
	喂食动物的方法
	获取动物的方法
 */
/**
 * 动物类
 * @author Anonymous
 *
 */
class Animal {
	
}

/**
 * 狗类，为Animal动物的子类
 * @author Anonymous
 *
 */
class Dog extends Animal {
	
}

/**
 * 熊猫类，为Animal动物的子类
 * @author Anonymous
 *
 */
class Panda extends Animal {
	
}

/**
 * 老虎类，为Animal动物的子类
 * @author Anonymous
 *
 */
class Tiger extends Animal {
	
}

public class Demo2 {
	public static void main(String[] args) {
		Animal animal = new Animal();
		Dog dog = new Dog();
		Tiger tiger = new Tiger();
		Panda panda = new Panda();
		
		// 这里传入一个Animal类对象
		feed(animal);
		
		// 这里可以传入Dog类对象，因为Dog类对象是Animal类的子类对象
		feed(dog);
		// 这里传入的对象是Tiger类对象，Tiger类是Animal的子类
		feed(tiger);
		// 同上
		feed(panda);
		
		// 数据类型强转，
		Dog dog2 = (Dog) getAnimal();
		System.out.println(dog2.getClass());
	}
	
	/**
	 * 该方法的是喂食【动物】的方法
	 * 
	 * @param animal 需要的参数是Animal类对象
	 */
	public static void feed(Animal animal) {
		// 获取当前对象的完整包名.类名
		System.out.println(animal.getClass() + "来吃饭了！！！");
	}
	
	/**
	 * 返回【动物】类对象的方法
	 * 
	 * @return Animal类对象
	 */
	public static Animal getAnimal() {
		// return new Animal();
		return new Dog();
		// return new Tiger();
		// return new Panda();
	}
}

public class Demo1 {
	public static void main(String[] args) {
		/*
		 * test方法使用了自定义泛型，传入的实际参数是什么类型
		 * 泛型T对应的具体数据类型是什么类型
		 */
		 // 首先定义几个变量
		Integer test = test(1234234);
		String test2 = test("武汉加油");
		Demo1 test3 = test(new Demo1());
		// 定义字符串类型数组
		String[] arr1 = { "星期一", "星期二", "星期三", "星期四", "星期五", "星期六" };
		// 调用方法
		printArray(arr1);

		System.out.println("-----------------------");
		
		// 定义Integer类型数组，Integer是int的包装类，可以理解为int大哥
		Integer[] arr2 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
		printArray(arr2);

		System.out.println("-----------------------");
		
		// 定义Demo1类型数组
		Demo1[] arr3 = {new Demo1(), new Demo1(), new Demo1(), new Demo1(), new Demo1()};
		printArray(arr3);
	}
	
	/*
	 * 声明一个带有自定义泛型的方法
	 */
	/**
	 * 带有自定义泛型声明的方法
	 * 
	 * @param <T> 自定义泛型无意义占位符
	 * @param t 指定的泛型数据类型，由用户约束
	 * @return 对应的T类型， 具体数据类型由用户约束
	 */
	public static <T> T test(T t) {
		return t;
	}
	
	/*
	 * 展示任意类型数组中数据的方法
	 */
	/**
	 * 展示任意类型数组的方式
	 * 
	 * @param <T> 自定义泛型无意义占位符
	 * @param arr 用户指定类型的数组，同时约束自定义泛型对应的具体数据类型
	 */
	public static <T> void printArray(T[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	} 
} 

/*
 * 定义一个带有自定义泛型的类
 */
class TypeA<T> {
	/**
	 * 使用和类名一致的自定义泛型，需要通过【类对象】来约束
	 * 
	 * @param t 对应泛型具体数据类型的参数
	 * @return 对应泛型具体数据类型的返回值
	 */
	public T test1(T t) {
		return t;
	}
	
	/**
	 * 使用和类名一致的自定义泛型，需要通过【类对象】来约束
	 * 
	 * @param t1 对应泛型具体数据类型的参数
	 * @param t2 对应泛型具体数据类型的参数
	 */
	public void test2(T t1, T t2) {
		System.out.println(t1);
		System.out.println(t2);
	} 
	
	/*
	 * 为什么类名自定义的泛型不能用于当前类内的静态成员方法
	 * 		静态成员方法是在类文件的加载阶段准备完毕，已经可以明确的保证该方法的是
	 * 可以执行的。
	 * 		如果使用类声明的自定义泛型，对应泛型的具体数据类型需要在创建类对象之后
	 * 才可以明确。
	 * 		当前静态方法在类文件加载阶段无法明确泛型数据类型是哪一个，也就无法保证
	 * 执行，【没有对象】
	 * 
	 * 如果方法想要使用自定义泛型，自娱自乐，自己定义自己用！！！
	 * 要求自定义的泛型占位符和类声明泛型占位符不一致，避免没有必要的歧义，提高阅读性
	 */
	public static <E> E staticMethod(E e) {
		return e;
	}
}

public class Demo2 {
	public static void main(String[] args) {
		/*
		 * 创建带有自定义泛型类的对象
		 * TypeA<String> typeA = new TypeA<String>(); Eclipse标准写法
		 * TypeA<String> typeA = new TypeA<>(); IDEA写法
		 */
		// 明确告知编译器，这里泛型对应的具体数据类型是String类型 
		// 类内所有使用到泛型占位符的位置都是的T类型
		TypeA<String> typeA = new TypeA<String>();
		
		String test1 = typeA.test1("北京烤鸭");
		typeA.test2("卤煮火烧", "豆汁");
		
		// 明确告知编译器这里泛型对应的具体数据类型是Demo2类型
		TypeA<Demo2> typeA2 = new TypeA<Demo2>();
		
		Demo2 test12 = typeA2.test1(new Demo2());
		typeA2.test2(new Demo2(),new Demo2());
		
		/*
		 * 没有告知编译器泛型对应的具体数据类型，那么在类内的所有非静态
		 * 成员方法方法中使用到的泛型， 都是Object类型，虽然可以支持任意
		 * 类型传入参数，但是缺少了数据类型一致化的约束。
		 * 
		 * 不推荐！！！
		 */
		TypeA typeA3 = new TypeA();
		
	}
}

interface A<T> {
	void test(T t);
}

/*
 * 接口带有泛型，遵从接口的实现类有两种方案可以implements当前接口
 * 		1. 自由
 * 		2. 规矩
 */

/**
 * 自由方式，类名之后和接口同名自定义泛型，泛型对应的具体数据类型是
 * 需要在创建当前类对象是进行约束使用。
 * 
 * @author Anonymous
 *
 * @param <T> 遵从接口和接口一致的泛型
 */
class TypeB<T> implements A<T> {

	@Override
	public void test(T t) {
		System.out.println("自由模式");
	}
	
}

/**
 * 规矩模式，遵从接口时，接口使用泛型对应的具体数据类型已经明确
 * 在类内使用接口中缺省属性为public abstract方法时，泛型已确认
 * 
 * @author Anonymous
 */
class TypeC<T> implements A<String> {

	@Override
	public void test(String t) {
		System.out.println("规矩模式");
	}
	
}

public class Demo3 {
	public static void main(String[] args) {
		/*
		 * 自由模式
		 */
		TypeB<Integer> typeB = new TypeB<Integer>();
		typeB.test(10);
		
		TypeB<Character> typeB2 = new TypeB<Character>();
		typeB2.test('A');
		
		TypeC typeC = new TypeC();
		
		typeC.test("比较无聊，但是很规矩");	
		
	}
}

public class Demo1 {
	public static void main(String[] args) {
		/*
		 * 因为Collection<E>是一个接口，接口没有自己的类对象
		 * 这里使用Collection接口的实现类来完成演示过程 ArrayList<E>
		 */
		Collection<String> c = new ArrayList<String>();
		
		c.add("82年的拉菲");
		c.add("82年的雪碧");
		c.add("82年的可乐");
		c.add("82年的老雪");
		
		System.out.println(c);
		
		Collection<String> c1 = new ArrayList<String>();
		
		c1.add("百威");
		c1.add("福佳白");
		c1.add("精酿啤酒");
		c1.add("修道院啤酒");
		
		c.addAll(c1);
		
		System.out.println(c);
		
		c.remove("82年的雪碧");
		System.out.println(c);
		
		//c.removeAll(c1);
		//System.out.println(c);
		
		//c.retainAll(c1);
		//System.out.println(c);
		
		System.out.println("size:" + c.size());
		System.out.println(c.isEmpty());
		
		System.out.println(c.contains("百威"));
		System.out.println(c.contains("哈尔滨"));
		
		System.out.println(c.containsAll(c1));
		
		c1.add("野格");
		System.out.println(c.containsAll(c1));
	}
}