Java——类的应用(一)

类的应用

1、final关键字的使用

       final是Java中一个非常重要的关键字，它既可以修饰一个成员变量，也可以修饰一个成员方法，同时还可以修饰一个类。当一个成员变量被定义为final时，这个成员变量只能赋值一次；当一个成员方法被定义为final时，这个成员方法不能被重写；当一个类被定义为final时，这个类不能被继承。

      1)、final常量的使用

      在变量前加上final，则变量将成为一个常量。对于此常量赋值时只能赋值一次，而且可以不再它所声明的那一行上赋值，但在构造函数完成之前必须保证此变量有一个值。下面是一个实例：

class test03

{

    int print()

    {

        final int a = 4;

        return a;

    }

}

 

public class test {

    public static void main(String[] args)

    {

        test03 t3 = new test03();

        System.out.println("a=" + t3.print());

    }

}

       一个类如果被定义成final，那么这个类只能被实例化一次，而且这个类中的方法参数也可以被定义成final；但如果定义成final，这个参数就只能赋值一次。下面是关于被定义为final的类的实例：

class test03

{

    int a;

    int print(int b)

    {

        return a + b;

    }

}

 

public class test {

    public static void main(String[] args)

    {

        final test03 t3 = new test03();

        t3.a = 1;

        System.out.println("a+b=" + t3.print(9));

        t3 = new test03();

    }

}

       我们会看到程序在t3 = new test03()这一行报错。这是因为test03被赋值了两次。

一个变量如果被定义成final类型，它就只能被赋值一次。不过下面的程序中b被赋值了两次，所以在编译时会报错：

class test03 {

    int print(final int b) {

        b = 9;

        return b;

    }

}

 

public class test {

    public static void main(String[] args)

    {

        test03 t3 = new test03();

        System.out.println("b=" + t3.print(9));

    }

}

我们会看到程序在b=2这一行报错。

       2)、最终方法

      当一个成员方法被定义为final时，该成员方法将不能被重写。不能重写提供了安全保护，但是防止子类重写该方法也失去了面向对象的很多优点。下面是一个被定义为final的方法不能被重写的实例：

class test02 {

    int a;

    final void print() {

        System.out.println("a=" + a);

    }

}

 

class test03 extends test02{

    int b;

    void print() {

        System.out.println("b=" + b);

    }

}

 

public class test {

    public static void main(String[] args) {

        test03 t3 = new test03();

        t3.b = 2;

        t3.print();

    }

}

我们会看到程序在test03中的print()方法上报错

       3)、最终类

       当一个类被定义为final时，这个类将不能派生出子类。任何类都不能继承final类。只有当认为该类中的所有方法都不需要重写时，才将该类定义为final。下面是一个final类的定义：

final class test02 {

    int a , b;

    void print() {

        System.out.println("a=" + a);

    }

    void print1() {

        System.out.println("b=" + b);

    }

}

 

class test03 extends test02{ }

 

public class test {

    public static void main(String[] args) {

        test03 t3 = new test03();

        t3.b = 2;

        t3.print();

    }

}

       不多说了，只要写下test03 extends test02，编译器马上就会报错。

2、静态修饰符

      由static修饰的成员变量或方法称为静态变量或静态方法。静态变量和静态方法都属于类，而不是属于任何具体的实例。当类中没有任何实例时，仍然可以访问静态变量和静态方法。只需要类名加”.”运算符就可以访问静态变量或调用静态方法。

      1)、静态变量

      静态变量也称为类变量，非静态变量称为实例变量(成员变量)。静态变量属于类，静态变量的值是保存在类的内存中的公共存储单元中，而不是保存在某一个对喜爱那个的内存空间中。当任何一个对象访问静态变量时，得到的值都是相同的。当一个对象对静态变量进行修改时，那么保存在类的内存中的公共存储单元中的值也将被修改。也就是说不管存在多少实例，静态变变量值分配一次值。下面是一个关于静态变量的实例：

class test03 { 

    static int a;

    int b;

}

 

public class test {

    public static void main(String[] args) {

        test03 t1 = new test03();

        test03 t2 = new test03();

        t1.a = 1;

        t1.b = 2;

        t2.a = 3;

        t2.b = 4;

        System.out.println("t1.a=" + t1.a);

        System.out.println("t1.b=" + t1.b);

        System.out.println("t2.a=" + t2.a);

        System.out.println("t2.b=" + t2.b);

    }

}

       我们会看到输出结果为：

              t1.a=3

             t1.b=2

             t2.a=3

             t2.b=4

       2)、静态方法

       静态方法也被称为类方法，一般是通过类的实例来调用静态方法。同时由于静态方法是属于类的，所以还可以通过类名来调用静态方法。下面分别通过类的实例和类名来调用静态方法。

class test03 { 

    static int a;

    static void print()

    {

        System.out.println("" + a);

    }

}

 

public class test {

    public static void main(String[] args) {

        test03 t1 = new test03();

        t1.a = 10;

        t1.print();

    }

}

       在一个类中，将变量定义成静态的，同时再将方法也定义成静态的，通过类名来调用类中静态的成员方法或成员变量。下面是一个通过类名来访问本类中的静态变量和方法的实例。

class test03 { 

    static int a;

    static void print()

    {

        System.out.println("" + a);

    }

}

 

public class test {

    public static void main(String[] args) {

        test03.a = 10;

        test03.print();

    }

       对于静态方法在类体内可以直接被其他方法调用(包括成员方法和静态方法)，在类体外可通过类名加”. ”运算符对其进行调用。静态方法能访问静态的成员变量，也能调用静态方法。但是静态方法不能访问成员变量，也不能调用非静态方法。下面是一个关于非晶态方法访问静态变量的实例：

class test03 { 

    static int a;

    int b;

    static void print() {

        System.out.println("这是一个静态的方法");

    }

    void print1() {

        //在成员方法中访问静态成员变量

        System.out.println(a);

        print();//在成员那方法中调用静态成员方法

    }

}

 

public class test {

    public static void main(String[] args) {

        test03 t3 = new test03();

        t3.a = 1;

        t3.print1();

    }

}

       在一个程序中，如果某个方法被定义成静态的，这个方法就不能访问非静态的方法或变量。如果静态的方法要访问非静态的方法就会报错。下面的实例显示了静态方法不可以访问非静态变量：

print1();

    }

    void print1() {

        //在成员方法中访问静态成员变量

        System.out.println("这是一个非静态的方法");

    }

}

 

public class test {

    public static void main(String[] args) {

        test03 t3 = new test03();

        t3.a = 1;

        t3.print1();

    }

}

       上面的代码在静态方法print()中的System.out.println(b);和print1()这两行都会报错。因为在静态方法中访问了成员变量和非静态方法。