java基础部分(1)

本文主要包含Junit测试、Java的邦定机制、使用MessageFormat格式化输出字符串、单例类、创建具有实例缓存的枚举类、不可变类等的一些用法

1.Junit测试
1.在Junit中，通过@Test注解，可以运行一个方法。
@BeforeClass – 在测试时只运行一次。不可以单独运行。
@AfterClass – 在测试结束时只运行一次。
eg:

//要被测试的类
package cn.lsl;
public class Login {
	public void login(){
		System.out.println("Login...");
	}
	public void login2(){
		System.out.println("Login...222...");
	}
}

 

//测试类
package cn.test;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import cn.lsl.Login;
public class TestLogin {
	@BeforeClass			//先执行的代码，不能单独运行
	public static void aa(){
		System.out.println("Before.....");
	}
	@AfterClass				//后执行的代码，不能单独运行
	public static void bb(){
		System.out.println("After.......");
	}
	@Test
	public void tt(){
		Login l = new Login();
		l.login();
	}
	@Test
	public void tt2(){
		Login l = new Login();
		l.login2();
	}

}

2.Java的邦定机制
1）在编译时，所声明的变量与类型绑定，这叫做静态绑定。
2）运行时，静态方法与所声明的类型绑定，叫静态绑定
3）运行时，成员变量与所声明的类型绑定，叫静态绑定
4）运行时，成员方法与所声明的实例对象绑定，叫动态绑定
eg:

package cn.lsl.bound;
public class Animal {
	public String name = "animal";
	public static String age = "8888";
	public void eat(){
		System.out.println("Animal...Eat....");
	}
	public static void run(){
		System.out.println("Animal running....");
	}
}

//Cat继承Animial
package cn.lsl.bound;
public class Cat extends Animal{
	public String name = "Cat";
	public static String age = "333";
	public void eat(){
		System.out.println("Cat...Eat...");
	}
	public static void run(){
		System.out.println("cat running......");
	}
	public void clubm(){
		System.out.println("cccccccc");
	}
}

//测试类
package cn.test;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import cn.lsl.bound.Animal;
import cn.lsl.bound.Cat;
public class TestLogin {
	@Test
	public void bount(){
		Animal a = new Cat();
		//a.clubm();  错误	//运行时绑定，，，编译时绑定-静态绑定
		a.eat();		//实例方法，与对象绑定，叫动态绑定（只有这个是动态绑定，，，其他的都是静态绑定）
		a.run();		//静态方法与类型绑定，叫静态绑定
		System.out.println(a.name);	//静态绑定
		System.out.println(a.age);	//静态绑定
	}
}

3.使用MessageFormat格式化输出字符串

package cn.lsl;

import java.text.MessageFormat;
import java.util.Calendar;

//MessageFormat格式化输出字符串

public class MyMessageFormat {
	public static void main(String[] args){
//		String ss = MessageFormat.format("Hello {0}, in {1}", "jack", "beijing");
//		System.out.println(ss);
		
//		String ss = MessageFormat.format("Hello {0} {1}", new Object[]{"aaa",111});
//		System.out.println(ss);
		
//		String ss = MessageFormat.format("Hello {0} {1}", "aaa", 111);
//		System.out.println(ss);
		
//		String ss = MessageFormat.format("共有 {0, number, currency}元", 100);	//共有 ￥100.00元
//		System.out.println(ss);
		
		Calendar c = Calendar.getInstance();
		c.add(Calendar.DATE, 7);
		Object[] o = new Object[]{
			7,
			c.getTime(),
			"中国北京"
		};
		String str = 
			MessageFormat.format(
					"我将在{0, number}天之后，" +
					"即：{1, date, full}时间，" +
					"到达：{2}", o);
		System.out.println(str);
		
		str = 
			MessageFormat.format(
					"我将在{0, number}天之后，" +
					"即：{1,,date,full}时间，" +
					"到达：{2}",
					7,c.getTime(),"中国上海");
		System.out.println(str);
	}
}

输出结果:
我将在7天之后，即：2013年5月13日 星期一时间，到达：中国北京
我将在7天之后，即：13-5-13 下午6:24时间，到达：中国上海

4.单例类,是指只能拥有一个实例的类就是单例类。
单例类的两种模式,懒汉模式和饿汉模式
eg:

Person.java
package cn.lsl;

//单例类：是指只能拥有一个实例的类就是单例类
class Person {
	private Person(){}
//	//饿汉模式
//	public static Person p = new Person();
	
//	因为是静态的，所以在使用这个类的时候就会创建，但是有可能只声明，而不用，这样就会占用内存，所以使用懒汉模式
	
//	懒汉模式
	private static Person p;
	public static Person instance(){
		if(p==null){
			p = new Person();
		}
		return p;
	}
}

测试类：Main.java
package cn.lsl;

public class Main {
	public static void main(String[] args) {
//		//饿汉模式
//		Person p1 = Person.p;
//		Person p2 = Person.p;
//		System.out.println(p1==p2);
		
//		//懒汉模式
		Person p1 = Person.instance();
		Person p2 = Person.instance();
		System.out.println(p1==p2);
	}
}

拓展：创建实例的数量有限的类（例如一个类只能被创建两次，如性别类）

package cn.lsl;

//一个类只可以创建两次
public class Gender {
	private Gender(){}
	private static Gender MALE;
	private static Gender FMALE;
	public static Gender getMale(){
		if(MALE==null){
			MALE = new Gender();
		}
		return MALE;
	}
	
	public static Gender getFMale(){
		if(FMALE==null){
			FMALE = new Gender();
		}
		return FMALE;
	}
}

//测试类
Main.java
package cn.lsl;

public class Main {
	public static void main(String[] args) {
		Gender g1 = Gender.getFMale();
		Gender g2 = Gender.getMale();
		System.out.println(g1==g2);
	}
}

5.创建具有实例缓存的枚举类。
对于某一个对像，如果用户在读取时没有就创建一个新的并将其缓存起来。如果下次用户再次请求相同的数据就重新获取这个对像。
应用场景：假如访问某个城市的天气，刚开始都没有数据，当有用户请求某个城市的天气时，就把该城市存储起来。
（当用户重复多次根据一个key来获取一个对像时，要求是同一个对像。当用户使用不同的key请求时要求是不同的对像。）

package cn.lsl;

import java.util.HashMap;
import java.util.Map;

//具有实例缓存的枚举类

//Map<键，值>
//<name,new City()>


public class City {
	private City(){}
	private static Map<String,City> map = new HashMap<String,City>();
	public static City getCity(String name){
		City city = map.get(name);    //先查map
		if(city==null){				 //判断是否为空，如果为空没有请求过。
			city = new City();
			map.put(name, city);
		}
		return city;
	}
}

//测试类：
package cn.lsl;

public class Main {
	public static void main(String[] args) {		
		City sh = City.getCity("SH");
		City c2 = City.getCity("BJ");
		City c3 = City.getCity("SH");
		System.out.println(sh==c2);
		System.out.println(sh==c3);
	}
}

6.不可变类
要保证不可变类的安全性，需要不可变类采取保护性Copy，即将数据从新拷贝一份
（将原有内存空间中的数据，全部拷贝到新的内存空间来，从而实现内存空间的独立性。）

package cn.lsl;

//不可变类，拷贝一份

public class Clazz {
	private final String[] studs;
	public Clazz(String[] stud){
		studs = new String[stud.length];
		for(int i=0; i<studs.length; i++){
			studs[i] = stud[i];
		}
	}
	public void reCall(){
		for(String s : studs){
			System.out.println(s);
		}
	}
}

//测试类
package cn.lsl;

public class Main {
	public static void main(String[] args) {
		String[] ss = {"Jack","Rose","Tom","Jhon"};
		Clazz clz = new Clazz(ss);
		ss[0] = "SmallJack";
		ss[1] = null;
		clz.reCall();
	}
}