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.关于基本类型存放在哪里的问题；
