RSS

JAVA – ENCAPSULATION – INHERITANCE – INNER CLASS – IMPORT

08 May
一个文件中可以定义数个类,但是只能有一个类被设定为public,文件名称主文件名称必须与这个public的类同名。

public class Ball{
     private double radius;
     private String name;
     public Ball(){
          this(0.0, "NO NAME"); //调用构造函数,避免用构造函数名称来调用
     }
     public Ball(double radius, String name){
          this.radius = radius;
          this.name = name;//参数名称与域成员相同时,为了避免覆盖域成员的作用范围,用this关键字
     }
     public void setRadius(radius){
          this.radius = radius;
     }
}

如果在声明成员时不使用存取修饰词,则预设以包(package)为存取范围。也就是Package外无法存取。

静态成员属于类所有,不过它同样遵循public, protecte 与 private的存取限制。
静态方法也要注意存取权限限制。静态方法中不会有this的参考名称。由于没有this名称,所有在java的静态方法中不会允许使用非静态成员。事实上如果静态方法中使用非静态成员或者方法编译时会报错。

Java在加载类时,希望先进性一些类的初始化动作,可以使用static定义一个静态区块。

public class StaticBlockDemo{
        static{
            //Some initial programme code.
        }

}

重载方法(Overload) – 名称相同,但是可以根据参数行的不同而自动调用对应的方法。返回值的类型不可以作为方法重载的区别根据(其它的都相同就是返回值不同,这样被视为重复定义,出错)

在J2SE5.0中开始支持不定长度参数。

public class MathTool{
    public static int sum(int... nums){
        //使用...声明参数
        int sum = 0;
        for (int num : nums )    {
            sum += num
        }
        return sum;
    }
}

public class TestVariableArgs{
    public TestVariablesArgs(){
        int sum = 0;
        sum = MathTool.sum(1,2);
        sum = MathTool.sum(1,2,3,4);
    }
}

注意实际上方法中使用是把nums视为数组(int[] nums)。不定长度参数必须设定在最后,而且只能有一个。如public void someMethod(int arg1, int … varargs),但如果public void someMethod(int … varargs, int arg1)或者public void someMethod(int arg1, someClass … varargs, someClass2 … varargs2),这样就不对了。


类继承
public class
superClass{
    private int x;
    public superClass(){
    }
    public superClass(x){
        this.x = x;
    }
}
public class subClass extends superClass{
    private int y;
    public subClass(){
       
super();//调用基类的构造函数
    }
    public subClass(int x, int y){
        super(x);
        this.y = y;
    }
}

父类的private的成员和方法子类不能使用,父类的protected的成员和方法子类可以使用。

重写方法(OverWrite) – 子类可以重写父类方法的实现内容成员的存取权限,或者成员的返回值类型(重写返回类型是J2SE5.0的新功能)

public class superClass{
    private int x;
    public String greeting;
    public superClass(){
    }
    public superClass(x){
        this.x = x;
    }
    public void setGreeting(greeting){
        this.greeting = greeting;
    }
    public String getGreeting(){
        return this.greeting;
    }
    public void SayGreeting(){
        System.out.println(getGreeting());
    }
}
public class subClass extends superClass{
    private int y;
    public subClass(){
        super();//调用基类的构造函数
    }
    public subClass(int x, int y){
        super(x);
        this.y = y;
    }
    public void SayGreeting(){
        System.out.println("SubClass overwrites SuperClass’s method");
    }
}
...
    superClass xx = new subClass();
    xx.setGreeting("Allo");
    xx.SayGreeting();

这里直接调用子类的重写的方法,如果要在子类调用父类的构造函数或者方法,要这样super()或者super.methodName(),前提是父类的构造函数或者方法不可以是private的。
成员的存取权限的重写是要注意,可以增大父类方法的权限,不可以缩小父类方法的权限。比如父类的方法是public,子类重写方法不可以是private或者protected。如果父类是private,子类可以是protected或者public;如果父类类是protected,则子类是public。

final关键词用在变量上,表示变量一旦声明就不可以改变它的值:
final double PI = 3.1415926;
方法用final修饰表示该方法再也无法被子类重写(Overwrite):
public final String display(){… return xxString;}
类被final修饰,表示该类不能被继承:
public final class NoChildClass{}

抽象类

public abstract class AbstractClass{
    protected abstract int getUserrInput();
    protected abstract void showmessage(String message);
}
public class TextModeGame extends AbstractClass{
    protected int getUserInput(){
       
    }
    protected void showmessage(String message){

    }
}
...
    AbstractClass xx = new TextModeGame();
    ...
    xx.getUserInput();

接口

public interface IRequest1{
    public String display();
}
public interface IRequest2{
    public void resetPassword(String password);
}
public interface IRequest extends IRequest1, IRequest{
    public void sayHej();
}
public class ImplRequest extends IRequest{
    public String display(){}
    public void resetPassword(String password){}
    public void sayHej(){}
}

Member Inner Class & Local Inner Class & Anonymous Inner Class
这部分林信良的介绍比较幼稚,说实话,他写的那个Java5的读书笔记太傻了,没有任何的深度,所以我决定不再读了。明天把那本书给扔掉,看了感觉没什么收获,简直是傻瓜系列书的代表!

Advertisements
 
Leave a comment

Posted by on 05/08/2008 in JAVA

 

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

 
%d bloggers like this: