学习

导入静态属性：
import static java.lang.Math.*
java常用包：
java.lang: java核心类包括String\Math\System\Thread 等，无需导入，系统自动导入.
java.utill:包含java工具类、接口和集合框架类、接口 如 Arrays和List、Set等
java.net :网络编程相关接口
java.io:java输入输出的类
java.text：java格式化接口
java.sql:JDBC数据库相关接口
java.awt :抽象窗口集GUI
java.swing :Swing图像界面编程

java调用构造器前会先为对象分配内存空间，说明在执行构造器前对象已经创建
一旦自定义构造器就不在有默认构造器.
由于要创建所以构造器为public
在一个构造器中使用另一个构造器：
使用this如this(name,color)来构造，否则使用new会重新创建对象.，必须作为执行体第一条语句.
子类可以对父类的方法进行覆盖Override,子类返回值类型应该比父类更小或相等，访问权限要比父类更大或相等，都要是实例方法.对于父类是private就不存在重写问题.
可以用super调用被覆盖的方法
方法重载（overload），方法重写（override）
被覆盖的类属性通过父类名
通过super调用父构造器，也出现在第一行，所以super和this不会同时出现.
所以创建任何java对象，最先执行的是Object构造器.
引用变量有两个类型：编译时的类型，运行时的类型.
子类赋予父类，向上转型，对象的属性不具有多态性.

强制类型转换：
1.基本类型转换只能在数值类型之间，不能将数值转换成布尔型.
2.引用类型转换只能把父类转换成子类，没有继承关系无法转换，而且只能编译时父类，运行时子类才能转换.
通过 objPri instanceof String判断能否进行转换.

继承带来高复用，破坏了分装性，造成严重耦合.
不用在父类构造器中调用被子类重写的方法.
final防止继承

初始化块：
{static}{
//初始化块的可执行代码
}
static对应静态属性的静态初始化块比普通初始化块先执行，不能初始化实例属性.先执行父类和子类的静态初始化块
系统总是先调用定义的初始化块.在创建java对象时隐式执行，在执行构造器之前执行.
int a=6在初始块后执行.
当Java创建一个对象时，系统先为所有实例属性分配内存，然后执行初始化块，然后执行构造器.
初始化块传不了参数
静态初始化块和声明名类属性初始化等级相同，按排列顺序.

包装类：
定义8个包装类
允许把基本类型值直接赋给对应的包装类引用变量，也允许把包装类对象直接赋给基础类型变量.
8个包装类除Character之外还可以传入一个字符串参数来构建包装对象.
对于Boolean来说，传入不属于True或true的字符串都会变成false
boolean =bObj.booleanValue();
jdk1.5提供自动装箱和自动拆箱，变量间直接赋值.
Integer.paraInt("");

Sysytem.out.printlin(a)=System.out.println(a.toString)
可以重写toString()提供有效信息来描述对象
比如
public String toString()
{
return “Apple[color=”+color+",weight="+weight+"]";
}

对于任何不适null的x,x.equals(null)一定返回false.
成熟的equals
public boolean equals(Object obj)
{
if(this==obj)
{
return true;
}
if(obj!=NULL&&obj.getClass()==this.getClass())
{
Person perobj=(Person)obj;
if()
{
return true;
}
}
return false;

}

单例类：
如果只有一个资源则类只能创建一个实例，这个类叫单例类.为了避免其他类自由创建该类实例，将构造器使用private修饰，通过public static 方法创建，并通过一个static 类属性来缓存创建对象，来判断是否创建成功.

final变量：表示修饰的类、方法、变量不可改变.final 成员变量系统不会对其隐式初始化.
final 修饰引用变量时只保证引用对象的地址保持不变.
final修饰基本数据类型时，变量可以在编译时确定值所以符合常量命名规则.
final 方法不可重写
不可变类：8个包装类和String,实例属性不可变.
创建不可变类
1.使用private 和final修饰类属性
2.提供参数构造器
3.仅为该类的属性提供getter方法，不提供setter方法.
4.重写Object中的hashCode和equals

若类属性为非String的引用对象时，可以改变属性实例所以改进：
public class Person
{
private final Name name;
Pulic Person(Name name)
{
this.name=new Name(name.getFirstName(),name.getLastName());
}
Pulic Name getName()
{

    return new Name(name.getFirstName(),name.GetLastName());
}

}

缓存实例的不可变类：
使用一个static数组作为缓存池；盲目乱用缓存会导致系统性能下降.使用valueof来控制缓存，使用new 来创建新的对象.
public class CacheImmutale
{
private final String name;
private static CacheImmutale[] cache =new CacheImmutale[10];
private static int pos=0;
public CacheImmutale(String name)
{
this.name=name;
}
public boolean equals(Object obj)
{
if(obj instanceof CacheImmutale)
{
CacheImmutale ob=(CacheImmutale)obj;
if(name.equals(ob.getName()))
return true;
}
return false;
}
public static CacheImmutale valueof(String name)
{
for(int i=0;i<pos;i++)
{
if(name.equals(cache[i].getName())
return cache[i];
}
if(pos==10)
{
cache[0]=new CacheImmutale(name);
pos=1;
return cache[0];
}
else
{
cache[pos++]=new CacheImmutale(name);
return cache[pos-1];
}
}
public String getName()
{
return name;
}
public int hasCode()
{
return name.hasCode();
}

}

使用abstract定义抽象类和方法，具有抽象方法的类只能是抽象类，抽象类可以没有抽象方法.
抽象类不能被实例化，无法使用new.
抽象类：
1.定义一个抽象方法
2.继承一个抽象父类，没有实现父类包含的抽象方法
3.实现一个接口，但没有完全实现接口的抽象方法.
public abstract String getType();
abstract 不能修饰类方法
private和abstract不能同时出现

接口：不包含普通方法的抽象类.
接口是某批类所遵守的规范，定义一组公共方法.
不使用class 而使用interface
修饰符若省略，则采用包权限.接口可以继承多个父接口，不能继承类…
接口不包含构造器和初始化块，可以包含属性（常量）自动添加static final，都是public.
不允许定义静态方法.
一个java源文件中最多只能有一个public接口，与文件同名
类实现接口用：implements，在extends之后
1.接口只包含抽象方法，而抽象类不是
2.接口不能定义静态方法，而抽象类可以
3.接口只包含静态常量方法
4.接口不包含构造器，抽象类的构造器不是用来创建对象的，而是用来让子类调用父类的构造器做初始化
5.接口不包含初始化块

使用接口，将处理行为作为参数传入方法：

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,6,4};
pa.process(target,new PrintCommand());
pa.process(target,new AddCommand());
}
}
内部类：
内部类不允许其他类访问，可以直接访问外部类私有数据，外部类不能访问内部类的实现细节
外部类名.this.
匿名内部类适合创建仅需要一次使用的类.
方法内也可以定义内部类
局部内部类和匿名内部类不是类成员
成员内部类：静态内部类和非静态内部类
不允许在非静态内部类中定义静态对象
静态内部类不能访问外部类的实例成员
接口只能有静态内部类.只能定义public static
非静态内部类
OuterInstance.new InnerConstructor();
创建内部类的子类对象是必须有一个外部类对象
public class Subclass extends Out.In
{
public Subclass(Out out)
{
out.super(“hello”);
}
}
如果有一个内部子类的对象存在，则一定存在与之对应的外部类的对象.
静态内部类：
new OuterClass.InnerConstructor();

局部内部类：在方法中定义：
无需访问控制符和修饰符
匿名内部类：
1.创建匿名内部类时会立即创建一个该类的实例，必须且最多继承一个父类或实现一个接口，不能是抽象类
2.不能定义构造器，没有类名所以没有构造器。可以定义实例初始化块

若匿名构造器访问外部类的局部变量时，必须使用final来修饰外部类的局部变量.

闭包：
public enum Gender implements GenderDesc
{
MALE(“男”)
{
public void info()
{
Systen.out.println(“代表男性”)；
}
}，
FEMALE(“女”)
{
public void info()
{
System.out.println(“代表女性”)；
}
}
；
…
}