java进阶项目 java进阶篇

java高级开发（Java高级开发技术及应用）

一、eclipse进行调试的几种形式：

• 单步跳入【F5】：进入到代码之中观察；
• 单步跳过【F6】：不进入到代码中观察，只观察代码表面；
• 单步返回【F7】：后面的代码不再调试，返回到进入代码。
• 恢复执行【F8】：程序直接正常执行完毕。

二、java基础新特性：

1.可变参数

**要求：**设计一个方法，用于计算任意个数的整数的相加。这种开发需求，最初的时候只能够通过数组的方式来实现。

**范例：**最初的实现模式。

package cn.mldn.demo;

public class TestDemo {
	public static void main(String[] args) {
		System.out.println(add(new int[] {1}));
		System.out.println(add(new int[] {1,2,3,4}));
		System.out.println(add(new int[] {1,2,3,4,5,6,7}));
	}
	/**
	 * 实现任意个数的数据的相加处理操作
	 * @param data 要进行相加操作的数据
	 * @return 返回多个数据的相加结果
	 */
	public static int add(int[] data) {
		int sum = 0;
		for(int x=0; x<data.length; x++) {
			sum += data[x];
		}
		return sum;
	}
}

范例：现在的实现模式

package cn.mldn.demo;

public class TestDemo {
	public static void main(String[] args) {
		System.out.println(add()); //随意传数据的个数
		System.out.println(add(1,2,2)); //随意传递的内容
		System.out.println(add(new int[] {1,2,3,4})); //可变参数可以接收数组
		System.out.println(add(new int[] {1,2,3,4,5,6,7}));
	}
	/**
	 * 实现任意个数的数据的相加处理操作
	 * @param data 要进行相加操作的数据
	 * @return 返回多个数据的相加结果
	 */
	public static int add(int... data) { //本身还是一个数组
		int sum = 0;
		for(int x=0; x<data.length; x++) {
			sum += data[x];
		}
		return sum;
	}
}

原则：参数个数不确定，随意由用户传递。

注意点：如果要传递多类参数，可变参数写在最后。只能设置一个可变参数。

2.foreach循环（增强型for循环）

范例：原始数组通过for循环输出

package cn.mldn.demo;

public class TestDemo {
	public static void main(String[] args) {
		int data[] = new int[] {1,2,3,4,5};
		for(int x=0; x<data.length; x++) {
			System.out.println(data[x]);
		}
	}
}

for循环使用的新格式：

for(数据类型 临时变量：数组){
    //循环次数为数组长度，而每一次的循环都会顺序取出数组的一个元素赋值给临时变量
}

即：在for循环中没有必要再去使用索引取数据。

范例：使用增强型的for循环

package cn.mldn.demo;

public class TestDemo {
	public static void main(String[] args) {
		int data[] = new int[] {1,2,3,4,5};
		for(int x: data) {  //将数组中的每一个元素设置给x
			System.out.println(x); //这种循环避免了脚标问题
		}
	}
}

只适合于简单处理模式，避免了数组越界。

三、泛型：

1.泛型的基本使用

所谓的泛型指的就是在类定义的时候并不会设置类中的属性或方法中的参数的具体类型，而是类使用的时候进行定义。所有如果要想进行这种泛型的操作，就必须做一个类型标记的声明。

范例：定义Point类

package cn.mldn.demo;
//在Point类定义的时候完全不知道x和y的属性是什么类型，而由使用者决定
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("东经10度");
		p.setY("北纬10度");
		//第二步：取出数据
		String x = p.getX();  //避免了向下转型
		String y = p.getY();  //避免了向下转型
		System.out.println("x = "+x+",y = "+y);
	}
}

2.通配符（重点）

范例：观察如下的一段程序

package cn.mldn.demo;

class Message <T>{
	private T note;
	public void setNode(T node) {
		this.note = node;
	}
	public T getNode() {
		return note;
	}
}

public class TestDemo {
	public static void main(String[] args) {
		Message<String> msg = new Message<String>();
		msg.setNode("天天很帅气");
		fun(msg);
	}
	public static void fun(Message<String> temp) {
		System.out.println(temp.getNode());
	}
}

如果现在泛型的类型设置的不是String，而是Integer（泛型类型只允许设置类和接口，而不能够使用基本数据类型）。

不设置泛型：

public class TestDemo {
	public static void main(String[] args) {
		Message<Integer> msg = new Message<Integer>();
		msg.setNode(99);
		fun(msg); //出现错误，只能接收String
	}
	//如果没有设置泛型类型，默认用的类型就是Object
	public static void fun(Message temp) {
		temp.setNode("天天很帅气！");
		System.out.println(temp.getNode());
	}
}

所以得出结论，我们需要的解决方案：可以接收所有的泛型类型，但是又不能够让用户任意修改。那么就需要通配符来实现，使用“？”来处理。

public class TestDemo {
	public static void main(String[] args) {
		Message<Integer> msg = new Message<Integer>();
		msg.setNode(99);
		fun(msg); //出现错误，只能接收String
	}
	//此时使用的通配符“?”描述的它可以接收任意类型，但是由于不确定类型，所以无法修改。
	public static void fun(Message<?> temp) {
		System.out.println(temp.getNode());
	}
}

在“？”的基础上又产生了两个子通配符：

• ？extends类：设置泛型上限：

|-例如：？extends Number，表示只能够设置Number或其子类，例如：Integer、Double等；

• ？super类：设置泛型下限：(方法的参数上)

|-例如：？super String，表示只能够设置String或其父类：Object。

范例：观察泛型上限

package cn.mldn.demo;

class Message <T extends Number>{
	private T note;
	public void setNode(T node) {
		this.note = node;
	}
	public T getNode() {
		return note;
	}
}

public class TestDemo {
	public static void main(String[] args) {
		Message<Integer> msg = new Message<Integer>();
		msg.setNode(99);
		fun(msg); //出现错误，只能接收String
	}
	//此时使用的通配符“?”描述的它可以接收任意类型，但是由于不确定类型，所以无法修改。
	public static void fun(Message<? extends Number> temp) {
		System.out.println(temp.getNode());
	}
}

3.泛型接口

范例：定义一个泛型接口

interface 	IMesssage<T>{ //在接口上定义了泛型
	public void print(T t);
}

对于这个接口的实现子类有两种做法：

范例：在子类定义的时候继续使用泛型

package cn.mldn.demo;

interface 	IMesssage<T>{ //在接口上定义了泛型
	public void print(T t);
}

class MessageImpl<T> implements IMesssage<T>{
	public void print(T t) {
		System.out.println(t);
	}
}

public class TestDemo {
	public static void main(String[] args) {
		IMesssage<String> msg = new MessageImpl<String>();
		msg.print("Hello world!");
	}
}

范例：在子类实现接口的时候明确给出具体类型

package cn.mldn.demo;

interface 	IMesssage<T>{ //在接口上定义了泛型
	public void print(T t);
}

class MessageImpl implements IMesssage<String>{
	public void print(String t) {
		System.out.println(t);
	}
}

public class TestDemo {
	public static void main(String[] args) {
		IMesssage<String> msg = new MessageImpl();
		msg.print("Hello world!");
	}
}

4.泛型方法

泛型方法不一定定以在泛型类或接口里面，也可以单独定义。

范例：定义泛型方法

public class TestDemo {
	public static void main(String[] args) {
		Integer data[] = fun(1,2,3,4);
		for(int temp:data) { //迭代和自动拆箱
			System.out.println(temp);
		}
	}
	//<T>描述的是泛型标记的声明
	public static <T> T[] fun(T...args) {
		return args;
	}
}

四、枚举：

1.认识枚举

多例设计模式特点：构造方法私有化，而后类内部需要提供有若干个实例化对象，后面通过static方法返回。

范例：定义一个描述颜色基色的多例设计类

package cn.mldn.demo;

class Color{
	private static final Color RED = new Color("RED");
	private static final Color GREEN = new Color("GREEN");
	private static final Color BLUE = new Color("BLUE");
	private String title;
	private Color(String title) {
		this.title = title;
	}
	public static Color getInstance(int ch) {
		switch(ch) {
		case 0 : return RED;
		case 1 : return GREEN;
		case 2 : return BLUE;
		default : return null;
		}
	}
	public String toString() {
		return this.title;
	}
}

public class TestDemo {
	public static void main(String[] args) {
		System.out.println(Color.getInstance(0));
	}
}

目的：限制本类实例化对象的产生个数。

范例：基于枚举开发

enum Color{
	RED,GREEN,BLUE
}

public class TestDemo {
	public static void main(String[] args) {
		System.out.println(Color.RED);
	}
}

实际上枚举就是一种高级的多例设计模式。

2.Enum类

使用Enum定义的枚举类本质上就相当于一个class定义的类继承了java.lang.Enum父类。

在Enum类里面有以下的方法：

• 构造方法：protected Enum(String name,int ordinal);

|-当定义枚举类中对象的时候自动设置序号和名字；

• 取得枚举名字：public final String name();
• 取得枚举的序号：public final int ordinal();

范例：观察方法的使用

enum Color{
	GREEN,RED,BLUE
}

public class TestDemo {
	public static void main(String[] args) {
		System.out.println(Color.RED.ordinal()+"="+Color.RED.name());
	}
}

取得所有的枚举数据的方法：values()返回的是一个枚举的对象数组；

范例：取得所有的枚举数据

enum Color{
	RED,GREEN,BLUE
}

public class TestDemo {
	public static void main(String[] args) {
		for(Color temp: Color.values()) {
			System.out.println(temp.ordinal()+"="+temp.name());
		}
	}
}

3.定义枚举其他机构

可以在枚举里面定义属性、方法或者实现接口。

范例：在枚举中定义更多的结构

enum Color{
	RED("红色"),GREEN("绿色"),BLUE("蓝色");  //如果定义有很多内容，枚举对象必须写在第一行
	private String title;
	private Color(String title) { //构造方法绝对不能使用public
		this.title = title;
	}
	public String toString() { //覆写Object类中的方法
		return this.title;
	}
}

public class TestDemo {
	public static void main(String[] args) {
		System.out.println(Color.RED);
	}
}

范例：让枚举实现接口

package cn.mldn.demo;

interface IColor{
	public String getColor();
}

enum Color implements IColor{  //实先了IColor的接口
	RED("红色"),GREEN("绿色"),BLUE("蓝色");  //如果定义有很多内容，枚举对象必须写在第一行
	private String title;
	private Color(String title) { //构造方法绝对不能使用public
		this.title = title;
	}
	public String toString() { //覆写Object类中的方法
		return this.title;
	}
	public String getColor() {
		// TODO Auto-generated method stub
		return this.title;
	}
}

public class TestDemo {
	public static void main(String[] args) {
		IColor ic = Color.RED;
		System.out.println(ic.getColor());
	}
}

4.枚举应用

枚举最大的特点是只有指的几个对象可以使用。

package cn.mldn.demo;

class Person{
	private String name;
	private int age;
	private Sex sex;
	public Person(String name,int age,Sex sex) {
		this.name = name;
		this.age = age;
		this.sex = sex;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", sex=" + sex + "]";
	}
}

enum Sex{
	MALE("男"),FEMALE("女");
	private String title;
	private Sex(String title) {
		this.title = title;
	}
	public String toString() {
		return this.title;
	}
}

public class TestDemo {
	public static void main(String[] args) {
		Person per = new Person("张三", 20, Sex.MALE);
		System.out.println(per);
	}
}

枚举本身还支持switch判断。

enum Sex{
	MALE,FEMALE;
}

public class TestDemo {
	public static void main(String[] args) {
		switch(Sex.MALE) {
		   case MALE : 
			   System.out.println("男人");
			   break;
		   case FEMALE : 
			   System.out.println("女人");
			   break;
		}
	}
}