-
为什么有构造器的存在？
一直以来，都构造器的设计初衷都感到不解，为什么设计Java时，有构造器这样的存在。一般在写c的时候，通常，我们对一个模块初始化的时候，都会时候一个函数初始化这个模块。所以Java直接引入构造器的概念来完成这个工作。
-
枚举类型
枚举类型的关键字是enum，实际上，和int、char等基本数据类型一样，也可以将enum创建的类看做是一种数据类型。数据的值有enum的成员决定。如：
enum Chars{
A , B , C
}
这个枚举类型Chars表明；Chars只有3个可取数据。就相当于int型的数据只有整数一样。
使用数据的时候；
Chars a = Chars.A；
Chars b = Chars.B;
Chars c = Chars.C;
基本使用方法
public static void foo6(){
Chars a= Chars.A;
// default case ; toString() method to use for all enum type
// for example the following
System.out.println(a);
//others method; the usage of vaules() and ordinal() as follow
for (Chars i : Chars.values()) {
System.out.println(i+" ordinal is " + i.ordinal());
}
-
代理（Proxy）
有时候，我们希望给用户的接口屏蔽底层实现；这时候可以使用代理。如：
我们有一个飞船的控制模块Control：
/**
how to use Proxy
*/
// this is a spaceship control module
class Controls{
public void up(int velocity){}
public void down(int velocity){}
public void right(int velocity){}
public void left(int velocity){}
public void forward(int velocity){}
public void back(int velocity){}
}
我们可以采用继承的方式实现一个飞船。
// a way to construct a spaceship is interheit
class SpaceShip{
private String name;
SpaceShip(String name){
this.name = name;
}
public static void main(String[] args) {
// this way can construct a spaceship through new keywords to create a object
// but it will expose the implementation details of based control module
SpaceShip spaceship = new SpaceShip("Racketer");
}
}
但是这种实现方式有一个问题，其中的spaceship 对象将会暴露控制模块的实现，也就是会得到Controls的所有成员变量和成员方法。这是不希望的。用户模块SpaceShip可以得到Controls的任何的动作。
为了解决这个问题，使用下面的代理模式：
// otherwise way is apply Proxy to spaceship,
// it can hide the implementation of based control module
class SpaceshipProxy{
private String name;
// create a control module
private Controls control = new Controls();
SpaceshipProxy(String name){
this.name = name;
}
public void up(int velocity){
control.up(velocity);
}
public void down(int velocity){
control.down(velocity);
}
public void right(int velocity){
control.right(velocity);
}
public void left(int velocity){
control.left(velocity);
}
public void forward(int velocity){
control.forward(velocity);
}
public void back(int velocity){
control.back(velocity);
}
public static void main(String[] args) {
SpaceshipProxy protector = new SpaceshipProxy("protector");
protector.back(100);
}
}
可以看出，我可以得到Controls的所有动作，但是至于底层实现，却被屏蔽了，用户protector对象不能直接得到Controls的动作，而是通过SpaceshipProxy 得到的。
总之，代理就是：把直接的实现变为间接的实现。
-
@Override注解
如果想在子类中覆写一个方法而不是重载，使用@Override注解。
class Homer{
public char doh(char c){
System.out.println("Homer----doh(char)");
return 'd';
}
public float doh(float f){
System.out.println("Homer----doh(float)");
return 1.0f;
}
}
class M{}
class Sar extends Homer{
public void doh(M m){
System.out.println("Bar----doh");
}
}
class Bar extends Sar{
// when you want to over ride a method but not overload ; using annotation @Override
@Override
public void doh(M m){
System.out.println("Sar----doh");
}
}
public class Hide{
public static void main(String[] args) {
Bar bar = new Bar();
bar.doh(1.0f);
bar.doh('a');
bar.doh(new M());
}
}
-
向上转型（upcasting）
在子类中用到父类的类型时，子类向父类转型。如：
class Instrument{
public void play(){}
public static void turn(Instrument i){
System.out.println("Instrument---based class");
i.play();
System.out.println("Instrument---i.play()");
}
}
// 当参数需要父类的时候，子类要转换成父类
public class Wind extends Instrument{
public static void main(String[] args) {
Wind w = new Wind();
// upcasting
Instrument.turn(w);
}
}
