为了结局8个基本数据类型的变量不能当成Object类型变量使用的问题，Java提供了包装类（Wrapper Class）
boolean b1 = true;
Boolean b1Obj = new Boolean(b1);
int it = 5;
Integer itObj = new Integer(it);
Float f1 = new Float("4.56");
Boolean bObj = new Boolean("false");
boolean bb = bObj.booleanValue();
int i= itObj.intValue();
float f = f1.floatValue();
自动装箱和自动拆箱
Integer inObj = 5;
Object boolObj = true;
int it = inObj;
包装类还可实现基本类型变量和字符串之间的转换，除了Character之外的所有包装类都提供了一个parseXxx（String s）
静态方法，用于将一个特定字符串转换成基本类型变量：除此之外，在String类里也提供了多个重载valueOf（）方法，
用于将基本类型变量转换成字符串。
String intStr = "123";
int it = Integer.parseInt(intStr);
String floatStr = "4.56";
float ft = Float.parseFloat(floatStr);
String ftStr = String.valueOf(2.345f);
String dbStr = String.valueOf(3.344);
String boolStr = String.valueOf(true);
把基本类型变量转换成字符串，还有一种更简单的方法：将基本类型变量和""进行连接运算，
String intStr = 5 +"";
==不可比较类型上没有父子关系的两个对象。
int it = 65;
float f1 = 65.0f;
(it == f1) true
char ch = 'A';
(it == ch) true;
下面是两个引用类型变量
String str1 = new String("hello");
String str2 = new String("hello");
(str1 == str2) false
(str1.equals(str2)) true
String已经重写了Object的equals()方法，String的equals（）方法
判断两个字符串相等的标准是：只要两个字符串所包含的字符序列相同，通过
equals()比较将返回true；否则将返回false。
比较成熟的equals()方法应保持如下形式
public boolean equals(Object obj)
{
//待比较的两个对象是同一个对象，直接返回true
if(this==obj)
{
return true;
}
//只有当obj是Person对象
if(obj != null && obj.getClass() == Person.class)
{
Person personObj = (Person)obj;
//并且当前对象的idStr与obj对象的idStr相等才可判断啷个对象相等
//idStr是Peson的一个属性变量
if(this.getIdStr().equals(personObj.getIdStr()))
{
return true;
}
}
return false;
}
如果一个类始终只能创建一个实例，则这个类被称为单例类。
把该类的构造器使用private修饰。
一旦把该类的构造器隐藏起来，则需要提供一个public方法作为该类的访问点，用于创建该类的对象，
且该方法必须使用static修饰。（因为调用该方法之前还不存在对象，因此调用该方法的不可能是对象，只能是类）
class Singleton
{
//使用一个变量来缓存曾经创建的实例
private static Singleton instance;
//将构造器使用private修饰，隐藏该构造器
private Singleton(){}
//提供一个静态方法，用于返回Singleton实例
//该方法可以加入自定义的控制，保证只产生一个singleton对象
public static Singleton getInstance()
{
//如果instance为null，标明还不曾创建singleton对象
if(instance == null)
{
//创建一个singleton对象，并将其缓存起来
instance = new Singleton();
}
return instance;
}
}
public class TestSingleton
{
public static void main(String[] args)
{
//创建Singleton对象不能通过构造器，只能通过getInstance方法
Singleton s1= Singleton.getInstance();
Singleton s2= Singleton.getInstance();
//将输出true
System.out.println(s1==s2);
}
}
在接口中定义属性时，不管是否使用public static final修饰符，接口里的属性总将使用这三个修饰符来修饰。
接口里只能包含抽象方法，不包含已经提供实现的方法：抽象类则完全可以包含普通方法。
接口里不能定义静态方法；抽象类里可以定义静态方法。
接口里只能定义静态常量属性，不能定义普通属性：抽象类里则既可以定义普通属性，也可以定义静态常量属性。
接口不包含构造器；抽象类里可以包含构造器，抽象类里的构造器并不是用于创建对象，而让其子类调用这些构造器来完成属于抽象类的初始化操作。
接口里不能包含初始化块，但抽象类则完全可以包含初始化块。
一个类最多只能有一个直接父类，包括抽象类；但一个类可以直接实现多个接口，通过实现多个接口可以弥补Java单继承的不足。
命令模式
public interface Command
{
void process(int[] target);
}
public class ProcessArray
{
public void process(int[] target,Command cmd)
{
cmd.process(target);
}
}
public class TestCommand
{
public static void main(String[] args)
{
ProcessArray pa = new ProcessArray()
int[] target = {3,-4,5,4};
pa.process(target,new PrintCommand());
System.out.println("..............");
pa.process(target,new AddCommand());
}
}
public class PrintCommand implements Command
{
public void process(int[] target)
{
for(int tmp : target)
{
System.out.println("迭代输出目标数组的元素"+tmp);
}
}
}
public class AddCommand implements Command
{
public void process(int[] target)
{
int sum = 0;
for(int tmp : target)
{
sum+=tmp;
}
System.out.println("数组元素总和是："+sum);
}
}
工厂模式
public interface Output
{
int MAX_CACHE_LINE = 50;
void out();
void getData(String msg);
}
interface Product
{
int getProductTime();
}
public class Printer implements Output,Product
{
private String[] printData = new String[MAX_CACHE_LINE];
private int dataNum =0;
public void out()
{
while(dataNum > 0)
{
System.out.println("打印机打印"+printData[0]);
//将作业队列整体前移一位，并将剩下的作业数减1
System.arraycopy(printData,1,printData,0,--dataNum);
}
}
}
public void getData(String msg)
{
if(dataNum >= MAX_CACHE_LINE)
{
System.out.println("输出队列已满，添加失败");
}
else
{
printData[dataNum++] = msg;
}
}
public int getProductTime()
{
return 45;
}
public static void main(String[] args)
{
//创建一个Printer对象，当成Output使用
Output o = new Printer();
o.getData(" 11111111");
o.getData(" ddddddd");
o.out();
Product p = nw Printer();
System.out.println(p.getProduceTime());
//所有接口类型的引用变量都可直接赋给java.lang.Object类型的变量
Object obj = p;
}
public class Computer
{
private Output out;
public Computer(Output out)
{
this.out = out;
}
public void keyIn(String msg)
{
out.getData(msg);
}
public void print()
{
out.out();
}
}
public class OutputFactory
{
public Output GetOutput()
{
//下面两行代码用于控制系统到底使用Output的哪个实现类
//return new Printer();
return new BetterPrinter();
}
public static void main(String[] args)
{
OutputFactory of = new OutputFactory();
Computer c = new Computer(of.getOutput);
c.keyIn("ddddddd");
c.keyIn("aaaaaa");
c.println();
}
}
public class BetterPrinter implements Output
{
private String[] printData = new String[MAX_CACHE_LINE * 2];
//用以记录当前需打印的作业数
private int dataNum = 0;
public void out()
{
//只要还有作业，继续打印
while(dataNum > 0)
{
System.out.println("高速打印机正在打印：" + printData[0]);
//把作业队列整体前移一位，并将剩下的作业数减1
System.arraycopy(printData , 1, printData, 0, --dataNum);
}
}
public void getData(String msg)
{
if (dataNum >= MAX_CACHE_LINE * 2)
{
System.out.println("输出队列已满，添加失败");
}
else
{
//把打印数据添加到队列里，已保存数据的数量加1。
printData[dataNum++] = msg;
}
}
}