泛型涉及的基本知识点

可变参数

要设计一个方法，用于计算任意参数的整数相加结果，早期只能用数组来实现
可变参数方法的定义格式
public [static] [final] 返回值方法名称([参数类型参数名称][参数类型...参数名称]) {}
这个参数上使用的"..."实际上表示一个数组的结构。
如果要传递各类参数，可变参数一定要放到最后，并且只能设置一个可变参数

public class Test{
public static void main(String[] args){
	System.out.println(add("Hello"));
	System.out.println(add("Hello",1,4,5,6));
	System.out.println(add("Hello",new int[]{1,2,3}));
	System.out.println(add("Hello",new int[]{1,2,3,4,5,6,7,8}));
	
	}
public static int add(String msg,int...data){
	int result=0;
	for(int i=0;i<data.length;i++) {
		result+=data[i];
	}
	return result;
}
}

结果

16
6
36

foreach循环(增强型for循环)：此种方式很好的避免了越界的问题，但是这种数组的操作只适合简单输出模式。
格式：for(数据类型临时变量：数组(组合)) {

//循环次数为数组长度，而每一次循环都会顺序取出数组中的一个元素赋值给临时变量

}

静态导入：

定义一个MyMath类，这个类提供了static方法

 class MyMath{
	public static int add(int x,int y) {
		return x+y;
	}
	public static int sub(int x,int y) {
		return x-y;
	}
}
public class Test{
	public static void main(String[] args) {
		System.out.println(add(10,20));
		System.out.println(sub(30,10));
	}
}

从JDK1.5开始，如果类中方法全是static方法，则可以直接把这个类的方法导入进来，这样就好比像在主类中定义的方法那样，可以被主方法直接调用。

泛型

从JDK1.5之后引入了三大常用新特性：泛型，枚举，注解。泛型可以帮助我们解决程序的参数转换问题
//在java中只有一种类型可以保存所有类型：Object型
//class Point{
// private Object x;
// private Object y;
// public Object getX() {
// return x;
// }
// public void setX(Object x) {
// this.x = x;
// }
// public Object getY() {
// return y;
// }
// public void setY(Object y) {
// this.y = y;
// }
// }
//Point p=new Point();
//p.setX(10);//自动装箱并向上转型为Object
//p.setY(20);
////取出数据
//int x=(Integer)p.getX();//强制向下转型为Integer并且自动拆箱
//int y=(Integer)p.getY();
//System.out.println("x= "+x+",y="+y);
//Point p=new Point();
//p.setX("东经80度");
//p.setY("北纬20度");
//p.setX(10.2);//这个时候由于设置方的错误，将坐标内容设置成了double与string,但是接收方不知道，于是在执行时就会出现错误，ClassCastException指的是两个
//没有关系的对象进行强转出现的异常。
//这个时候语法不会对其做任何限制，但执行的时候出现了程序错误，所以得出了结论:向下转型时不安全的操作，会带来隐患。
//p.setY("北纬20度");
//取出数据
//String x=(String)p.getX();
//String y=(String)p.getY();
//System.out.println("x= "+x+",y="+y);

//设置整型坐标
//设置数据

//设置字符串
//设置数据
//Point p=new Point();
//p.setX("东经80度");
//p.setY("北纬20度");
//取出数据
//String x=(String)p.getX();
//String y=(String)p.gety();
//System.out.println("x= "+x+",y="+y);

//泛型类的基本使用
//泛型指的就是在类定义的时候并不会设置类中的属性或方法中的参数的具体类型，而在类使用时再进行定义。
//如果要想进行这种泛型的操作，就必须做一个类型标记的声明.
//泛型类的基本语法
//class MyClass<T>{
// T value1;
//}
//尖括号<>中的T被称作类型参数，用于指任何类型。实际上这个T可以任意写，但出于规范的目的，java还是建议我们用单个大写字母来代表类型参数。常见的如：
//T代表一般的任何类。
//E代表Element的意思，或者Exception异常的意思。
//K代表Key的意思
//V代表Value的意思，通常与K一起配合使用。
//S代表Subtype的意思
//如果一个类<T>的形式定义，那么它就被称为时泛型类。
//MyClass<String> myClass1=new MyClass<Strin>();
//MyClass<Integer> myClass2=new MyClass<Integer>();
//注意：泛型只能接受类，所有的基本数据类型必须使用包装类！泛型类可以接收多个类型参数
//泛型的出现彻底改变了向下转型的需求，引入泛型后，如果明确设置了类型，则为设置类型；如果没有设置类型，则默认为Object类型。
//class Point<T> {//T表示参数，是一个占位的标记；如果有多个泛型就继续在后面追加
// private T x;
// private T y;
// public T getX() {
// return x;
// }
// public void setX(T x) {
// this.x = x;
// }
// public T getY() {
// return y;
// }
// public void setY(T y) {
// this.y = y;
// }
//
//}
//public class TestDemo{
// public static void main(String[] args) {
// Point<String> p=new Point<String>();
// p.setX("东经80度");
// p.setY("北纬20度");
// String x=p.getX();
// String y=p.getY();
// System.out.println("x= "+x+",y="+y);
// }
//}
//泛型方法
//class MyClass{
// public <T> void testMethod(T t) {
// System.out.println(t);
// }
//}
//泛型方法与泛型类稍有不同的地方是，<T>被称为类型参数，写在返回值前面。而方法中的T被称为参数化类型，它不是运行时真正的参数。当然，声明的类型参数其实也可以
//当作返回值的类型的。
//class MyClass{
// public <T> void testMethod(T t) {
// return t;
// }
//}
//泛型方法与泛型类可以共存
//泛型中的类型参数与泛型方法中的类型参数是没有相应的联系的，泛型方法始终以自己定义的类型参数为准。
//如果在一个泛型类中存在泛型方法，那么两者的类型参数最好不要同名。
//class MyClass<T>{//泛型类
// public void testMethod1(T t) {//泛型类中的普通方法
// System.out.println(t);
// }
// public <T> T testMethod2(T t) {//泛型方法
// return t;
// }
//
//}
//public class TestDemo {
//public static void main(String[] args) {
// MyClass<String> myClass=new MyClass<>();
// myClass.testMethod1("hello 泛型类");
// Integer i =myClass.testMethod2(100);
// System.out.println(i);
//}//泛型类的实际类型是String,而传递给泛型方法的类型参数是Integer,两者不相干。
//
//}

//通配符
//追加了泛型定义避免了ClassCastException的问题，但是又会出现新的问题：参数的统一问题。
//可以接收所有的泛型类型，但又不能让用户门随意修改。这种情况需要通配符“？”来处理
//在"?"的基础上又产生了子通配符：
//?extend类：设置泛型上限：
//例如：?extend Number,表示只能设置Number或其子类，
//?super类：设置泛型下限。
//上限可以用在声明，不能修改，而下限只能用在方法参数，可以修改内容。
//class Message<T>{
// private T message;
// public T getMessage() {
// return message;
// }
//
// public void setMessage(T message) {
// this.message = message;
// }
//
//}
//public class TestDemo{
// public static void main(String[] args) {
// Message<String> message=new Message();
// message.setMessage("hello world");
// fun(message);
// }
// public static void fun(Message<? super String> temp) {
// temp.setMessage("bit");
// System.out.println(temp.getMessage());
// }
//}

//泛型接口
//泛型除了可以定义在类中，也可以定义在接口里面，
//interface IMessage<T>{
// public void print(T t);
//}
//class MessageImpl implements IMessage<String>{
// public void print(String t) {
// System.out.println(t);
// }
//}
//public class TestDemo{
// public static void main(String[] args) {
// IMessage<String> message=new MessageImpl();
// message.print("hello world");
// }
//}

//类型擦除
//泛型信息只存在于代码编译阶段，在进入JVM之前，与泛型相关的信息会被擦除掉，专业术语叫做类型擦除，通俗讲：泛型类和普通类在java中没什么特别的地方

//class MyClass<T>{
// private T message;
// public T getMessage() {
// return message;
// }
// public void setMessage(T message) {
// this.message=message;
// }
// public void testMethod1(T t) {
// System.out.println(t);
// }
//}
//public class TestDemo{
// public static void main(String[] args) {
// MyClass<String> myClass1=new MyClass<>();
// MyClass<String> myClass2=new MyClass<>();
// System.out.println(myClass1.getClass()==myClass2.getClass());
//
// }
//}
//打印的结果为true,因为MyClass<String>和MyClass<Integer>在JVM中的class都是MyClass.class.
//class MyClass<T,E>{
// private T message;
// private E text;
// public T getMessage() {
// return message;
// }
// public void setMessage(T message) {
// this.message = message;
// }
// public E getText() {
// return text;
// }
// public void setText(E text) {
// this.text = text;
// }
//}
//public class TestDemo{
// public static void main(String[] args) {
// MyClass<String,Integer> myClass1=new MyClass<>();
// Class cl1=myClass1.getClass();
// Field[] fields=cl1.getDeclaredFields();
// for(Field field:fields) {
// System.out.println(field.getType());
// }
// }
//}
//在泛型类被擦除的时候，之前泛型类中的类参数部分如果没有指定上限，如<T>则会被转译成普通的Object类型，如果指定了上限如<T extends String>则类型参数就被替换成
//类型上限。

泛型涉及的基本知识点

可变参数

泛型

猜你喜欢