java新特性功能

foreach循环

public class TestDemo {

	public static void main(String[] args) {
		
		int [] data  = new int [] {1,2,3,4,5};
		//foreach循环是for循环的加强型
		//循环每执行一次，数组角标向后移一位，把数组中相应数据设置给变量
		for (int x : data) {
			System.out.println(x + ",");
		}
		
	}

}

静态导入

package com.a.assist;

public class MyMath {

	public static int add(int x, int y) {
		return x + y;
	}	
	public static int div(int x, int y) {
		return x / y;
	}
	
}

package com.a.test;
//用下面语句导入表示把MyMath类中所有static 方法倒入本程序中
//在调用方法处不出现类名称
//前提是这个类中定义的方法都是static方法
import static com.a.assist.MyMath.*;
public class TestDemo {

	public static void main(String[] args) {
		
		System.out.println(add(1,2));
		System.out.println(add(10,2));

	}

}

可变参数

package com.a.assist;
//可变参数，方法传递的参数个数若干不确定时定义的形式
//统一用数组进行接收
public class Add {
	public static int add(int ... data) {
		int sum = 0;
		for (int x = 0; x < data.length; x++) {
			sum += data[x];
		}
		return sum;
	}
}

package com.a.master;

import com.a.assist.Add;

public class TestDemo {

	public static void main(String[] args) {
		
		System.out.println(Add.add(1,2,3));
		System.out.println(Add.add(1,2));

	}

}

泛型

package com.a.b;
//泛型主要解决当把Object作为类型定义属性和方法的数据类型时，取出数据对象向下
//转换时容易出现的类对象转换安全隐患，因为Object可以接受所有对象数据类型
//赋值时容易出现类型不同的赋值，运行前不容易发现
//泛型就是提前给类的属性和方法的数据类型提前标记占位，具体使用时在具体设置具体的类型
class Point<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 TestDemoA {
	public static void main(String args[]) {
		Point<String> p = new Point<String>();
		p.setX("东经108");
		p.setY("北纬20");
		String x = p.getX();
		String y = p.getY();
		System.out.println("x=" + x + " y=" + y);
	}
}

package com.a.c;
//通配符?为了解决接受同类中不同类型对象引用传递参数类型不同传参问题
class Message<T> {
	
	private T msg;

	public T getMsg() {
		return msg;
	}

	public void setMsg(T msg) {
		this.msg = msg;
	}
	
}
public class TestDemoB {

	public static void main(String[] args) {
		
		Message<String> m = new Message<String>();
		Message<Integer> s = new Message<Integer>();
		m.setMsg("吃饭");
		s.setMsg(1);
		fun(m);
		fun(s);

	}
	
	public static void fun(Message<?> temp) {
		
		System.out.println(temp.getMsg());
		
	}

}

package com.a.d;
//泛型接口
interface IMessage<T> {
	public abstract void print(T t);
}
class MessageImp implements IMessage<String> {
	//子类为父接口设置具体泛型类型
	public void print(String t) {
		System.out.println(t);
	}
}
public class TestDemoC {

	public static void main(String[] args) {
		
		IMessage<String> m = new MessageImp();
		m.print("输出内容");

	}

}

package com.a.e;
//泛型方法
public class TestDemoD {

	public static void main(String[] args) {
		
		String str = fun("lala");
		System.out.println(str.length());

	}
	
	public static <T>T fun(T t) {
		return t;
	}

}

枚举的实际应用

package cn.a.b;
//定义可用实例
//在switch语句中使用枚举
enum Color {
	RED,GREEN,BLUE;
}

public class TestDemo {

	public static void main(String[] args) {
		Color c = Color.RED;
		switch(c) {
			case RED:{
				System.out.println("红色");
				break;
			}
			case GREEN:{
				System.out.println("绿色");
				break;
			}
			case BLUE:{
				System.out.println("蓝色");
				break;
			}
		
		}
	}

}

package cn.a.c;
//在类结构中使用枚举
enum Sex {
	MALE("男"),FEMALE("女");
	private String title;

	private Sex(String title) {
		this.title = title;
	}
	public String toString() {
		return this.title;
	}
}
class Member {
	private String name;
	private int age;
	private Sex sex;
	public Member(String name, int age, Sex sex) {
		super();
		this.name = name;
		this.age = age;
		this.sex = sex;
	}
	public String toString() {
		return "Member [name=" + name + ", age=" + age + ", sex=" + sex + "]";
	}
}
public class TestDemo {

	public static void main(String[] args) {
		System.out.println(new Member("wu",18,Sex.MALE));

	}

}