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.......");}@Testpublic void tt(){Login l = new Login();l.login();}@Testpublic 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继承Animialpackage 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 {@Testpublic 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.javapackage 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.javapackage 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.javapackage 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);    //先查mapif(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();}}