菜鸡自学JAVA坎坷路day.19（泛型1）

1.testGeneric01

package testGeneric01;
/**
 *  获取值:
 * 1、强制类型转换
 * 2、手动类型检查:避免转换错误  java.lang.ClassCastException:
 * @author Wang
 *
 */

public class gen01 {
	public static void main(String[] args) {
		Object obj = 80;
		//int score =(int)obj; //jdk1.7以后 Object -->integer -->自动拆箱
		int score=(Integer)obj;
		System.out.println(score);
		
		//存入整数 int -->Integer -->Object
		Student stu = new Student(80,90);

		System.out.println("分数为:"+stu.getJavase()+","+stu.getOracle());
		
		int a = (Integer )stu.getJavase();//返回来的Object类型的   所以要强制转换
		
		System.out.println(a);
	}

}

package testGeneric01;
/**
 * Object 可以接收任意的类型  因为发生了多态
 * @author Wang
 *
 */

public class Student {
	private Object javase;
	private Object oracle;
	
	public Student() {
		
	}

	public Student(Object javase, Object oracle) {
		super();
		this.javase = javase;
		this.oracle = oracle;
	}

	public Object getJavase() {
		return javase;
	}

	public void setJavase(Object javase) {
		this.javase = javase;
	}

	public Object getOracle() {
		return oracle;
	}

	public void setOracle(Object oracle) {
		this.oracle = oracle;
	}
	
	
}

2.testGeneric02

package testGeneric02;
/**
 * 接口中泛型字母只能使用在方法中，不能使用在全局变量中
 * @author Wang
 *
 */

public class Comparator <T> {
	void compare(T t) {
		
	}
}

package testGeneric02;

import java.io.Closeable;
import java.io.IOException;

/**
 * 测试泛型方法的使用：
 * 1.泛型方法<>（<>里面的东西代表类型变量） 要加在修饰符的后面  返回值类型之前
 * 2.泛型方法只能访问对象信息而不能修改对象信息
 * @author Wang
 *
 */

public class TestMethod {
	public static void main(String[] args) {
		test("a");
	}
	
	public static <T> void test(T a) {//这是一个泛型方法  （为什么有static修饰不是说泛型不能用在静态方法上吗）
		System.out.println(a);
	}
	
	public static <T extends Closeable> void test(T... a){		
		for(T temp:a){
			try {
				if(null!=temp){
					temp.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

package testGeneric02;
/**
 * 泛型类：在声明的时候使用泛型
 * 字母：
 * T  Type 表示类型
 * K V 分别代表键值对中  Key 和  Value
 * E  代表Element
 * 在使用时（创建对象时）确定泛型
 * 注意：
 * 1.泛型只能使用引用类型，不能是基本类型(引用类型  就是Integer  那种需要先声明  然后在在堆里创建对象那种)
 * 2.泛型声明时字母不能使用在静态属性或静态方法上；
 * 
 * @author Wang
 *
 */

public class Student <T1,T2> {
	private T1 javaScore;
	private T2 oracleScore;
	
	//泛型声明时不能使用 静态属性|静态方法上
	//private static T1 test;
	
	public T1 getJavaScore() {
		return javaScore;
	}

	public void setJavaScore(T1 javaScore) {
		this.javaScore = javaScore;
	}

	public T2 getOracleScore() {
		return oracleScore;
	}

	public void setOracleScore(T2 oracleScore) {
		this.oracleScore = oracleScore;
	}

	public static void main(String[] args) {
		//使用时指定类型(引用类型)
		Student<String,Integer> stu = new Student<String,Integer> ();
		
		//1、安全：类型检查
		stu.setJavaScore("优秀");
		
		//2、省心:类型转换
		int it =stu.getOracleScore(); //自动拆箱
	}

}

3.testGeneric03

package testGeneric03;
/**
 * 父类为泛型：这里把他的方法和属性都定义成泛型
 * 
 * 子类在继承的时候：
 * 1.可以同时擦处
 * 2.可以子类类型大于等于父类
 * 3.根据2可以得出不能子类擦出父类泛型
 * 
 * （1）.属性的类型
 * 1.父类中随父类而定
 * 2.子类中随子类而定
 * （2）.方法的重写：
 * 1.随父类而定（毕竟是重写父类的方法）
 * 
 * 
 * @author Wang
 *
 */

public abstract class Father <T,T1> {
	T name;
	public abstract void test(T t);
}

/**
 * 子类声明的时候指定具体类型
 * 子类里面的方法和属性就会变为具体类型
 * 
 */

class Child1 extends Father<String,Integer>{
	
	String name ;
	
	@Override
	public void test(String t) {
		// TODO Auto-generated method stub
		
	}
	
}

/**
 * 子类为泛型  他的类型就会在使用的时候确定
 */

class Child2<T,T1,T2> extends Father<String,Integer>{
	
	T name ;

	@Override
	public void test(String t) {//重写跟随父类而定
		// TODO Auto-generated method stub
		
	}
		
}
/**
 * 子类为泛型，父类不指定类型，这个就是泛型的擦除，擦除后是会使用Object进行替换
 * 
 */


class Child3 <T,T2> extends Father{
	
	T name;
	
	@Override
	public void test(Object t) {//泛型被擦除了
		// TODO Auto-generated method stub
		
	}
	
}

/**
 * 子类与父类同时擦除 
 */

class Child4 extends Father{//那么在这里使用泛型就毫无意义了  
	
	String name;

	@Override
	public void test(Object t) {
		// TODO Auto-generated method stub
		
	}
	
}


/*
子类擦除，父类使用泛型    这样是错误的  因为子类的范围小于父类的范围了
class Child5 extends Father<T,T1>{
	String name;	
	@Override
	public void test(T t) {
		
	}
*/

package testGeneric03;
/**
 * 泛型接口的实现：与继承父类是同理的
 * @author Wang
 *
 */

public interface Comparable <T> {
	void compare(T t);
}


//实现类不泛型  接口泛型
class Comp implements Comparable<Integer>{

	@Override
	public void compare(Integer t) {
		// TODO Auto-generated method stub
		
	}
	
}
//实现类不泛型   接口的擦除
class Comp1 implements Comparable{

	@Override
	public void compare(Object t) {
		// TODO Auto-generated method stub
		
	}
	 
}
//实现类泛型   接口擦除
class Comp2<T> implements Comparable{

	@Override
	public void compare(Object t) {
		// TODO Auto-generated method stub
		
	}
	 
}
//实现类泛型 >= 接口泛型
class Comp3<T,T1> implements Comparable<T>{

	@Override
	public void compare(T t) {
		// TODO Auto-generated method stub
		
	}
	 
}
//父类泛型，子类擦除 错误

//反正就是一句话   子类的范围  >=  接口

package testGeneric03;
/**
 * 在这里我们测试泛型的擦除
 * 1.继承或实现声明   不指定类型
 * 2.使用是不指定类型
 * 擦除以后就同意按照Object来对待    因为编译时不会类型检查
 * 
 * @author Wang
 *
 */

public class Student <T> {
	private T mathScore;
	private T englishScore;
	
	
	public T getMathScore() {
		return mathScore;
	}
	
	
	public void setMathScore(T mathScore) {
		this.mathScore = mathScore;
	}
	
	
	public T getEnglishScore() {
		return englishScore;
	}
	
	
	public void setEnglishScore(T englishScore) {
		this.englishScore = englishScore;
	}
	
	
	public static void main(String[] args) {
		Student stu = new Student();//这个就是擦除了  直接按照Object来对待
		
		test(stu);
		test1(stu);
		
	}
	
	public static void test(Student <Integer> a) {
		
	}
	
	public static  void test1(Student <?> a){
		
	}
	
}

4.关于基本类型存放在哪里的问题；