首页  >  文章  >  Java  >  04.Java 基础 - 类

04.Java 基础 - 类

黄舟
黄舟原创
2017-02-27 10:20:121629浏览

基本概念

在面向对象的概念中,我们知道所有的对象都是通过类来描绘的。

在 Java 中类通过关键字 class 来定义。

同样的在 Java 中类具有多种形式,包括普通类、抽象类、内部类。

其中内部类又包含了:成员内部类、局部内部类、匿名内部类、静态内部类。


普通类

这个没什么好说的。

public class Demo { }

抽象类

1.基本概念

上面提到所有的对象都是通过类来描绘的,但是并不是所有的类都是用来描绘对象的。

如果一个类中没有包含足够的信息来描绘一个具体的对象(我们可以理解为一种功能不全的类),这样的类就是抽象类

抽象类通过关键字 absract 定义。它可以包含抽象方法、非抽象方法。


2.实例探究

  • 抽象类定义

public abstract class Parent {

    // 1.成员变量,与普通类无差别
    private  String word="aa";    // 2.非抽象方法,与普通类无差
    private void talk(){
        System.out.println("Parent is talking");
    }    // 3.抽象方法,访问权限只能是 public 和 protected 
    abstract void print();
}
  • 抽象类继承

// 1.抽象类继承抽象类,抽象子类不用实现父类的方法public abstract class Son extends Parent { }
// 2.普通类继承抽象类,普通子类必须实现父类的所有抽象方法public class Grandson extends Son {
    @Override
    void print() {
        System.out.println("I am Grandson");
    }
}
  • 抽象类调用

// 错误,抽象类不允许被实例化//Parent parent = new Parent();

通过以上的代码,我们可以总结出这么几点:

  • 抽象类、抽象方法,不能被 private 修饰,且必须使用关键字 abstract 定义。

  • 子类如果不是抽象类,则必须实现父类所有的抽象方法。

  • 抽象类不允许被实例化,编译错误。

  • 抽象类里面也可以包含普通方法,成员变量。


成员内部类

1.基本概念

位于一个类内部的类,被称为成员内部类。

成员内部类具有以下特点:可以访问其外围类的所有属性,而不需要任何特殊条件。

2.实例探究

  • 成员内部类定义:

public class Outter {
    private int a = 10;    static int b = 20;    int c = 30;    // 内部类
    class Inner {        void print(int d) {
            System.out.println(a + "-" +b+ "-" +c+ "-" + "-" +d;
        }
    }    // 取得内部类
    Inner getInner() {        return new Inner();
    }
}
  • 成员内部类调用

Outter out = new Outter();// 创建内部类的两种方式:
Outter.Inner inner = out.new Inner();Outter.Inner inner2 = out.getInner();inner.print(20);

3.原理分析

通过反编译 class 文件,命令如下:

javap -v Outter

执行命令后,后得到两个 class 文件:Outter.Class 和 Outter$Inner.Class。

说明对于虚拟机来说,内部类其实与常规类是一样的。所以 Inner 仍然被编译成一个独立的类,而不是 Outter 类的某一个域。

但是由于成员内部类看起来像是外部类的一个成员,所以可以拥有与成员一样的访问权限。


局部内部类

1.基本概念

局部内部类有两种:

  • 方法内的类。

  • 作用域内的类。

可以将其视作方法或作用域的内局部变量,因此它的访问权限也仅限于方法内或者该作用域内。

同局部变量一样,它是无法被 public、protected、private、static 关键字修饰的。

2.实例探究

public class Man {
    public Object getWoman() {        // 注意:三个变量都相互不受影响
        int age = 30;        // 1.方法内的类
        class Woman {            int age = 20;
        }        // 2.作用域内的类,此时作用域为 if 
        if(true){
            class Son{                int age = 10;
            }
        }   
        return new Woman();
    }
}

匿名内部类

1.基本概念

匿名内部类是唯一一种没有构造器的类。因为这个特点,匿名内部类的使用范围非常有限,大部分用于接口回调

它具有以下特点:

  • 匿名内部类在编译的时候由系统自动起名为 Outter$1.class。

  • 匿名内部类一般用于继承其他类或是实现接口,并不需要增加额外的方法,只是对继承方法的实现或是重写。

  • 匿名内部类不能访问外部类方法中的局部变量,除非变量被声明为 final 类型


2.实例探究

public class Test {
    // a 属于全局变量
    int a =100;    public static void main(String[] args) {
        Test t = new Test();
        t.test(200);
    }    // b 属于局部变量
    public void test(final int b) {        // c 属于局部变量
        final int c = 300;        //  匿名内部类
        new Thread() {            int  d = 400;            public void run() {
                System.out.println(a+"-"+b+"-"+c+"-"+d);
            };
        }.start();
    }
}

3.原理分析

通过反编译命令可以得到两个 class 文件:Outter.class 和 Outter$1.class。

关于局部变量的生命周期:

  • 当方法被调用时,局部变量在栈中被创建。当方法运行结束后,退栈,局部变量死亡。

关于内部类对象的声明周期:

  • 创建一个匿名内部类对象,系统为该对象分配内存,直到没有引用变量指向分配给该对象的内存,它才会被 GC 处理。

因此存在情况:

  • 成员方法已调用结束,局部变量已死亡,但匿名内部类的对象仍然活着。

所以在 Java 中采用了 final 关键字+复制的办法来解决:

  • final 关键字:因为它的特性是一旦变量被赋值后,就不能被修改。

  • 复制:在匿名内部类中直接复制了一个与局部变量值的数,让它变成自己的局部变量。

所以当局部变量的生命周期结束后,匿名内部类照样可以访问 final 类型的局部变量,因为它自己拷贝了一份,且与原局部变量的值始终一致。

下面针对上面的代码来分析:

  • 当 test 方法执行完毕之后,变量 b、c 的生命周期就结束了。然而 Thread 对象的生命周期很可能还没有结束。因此要将 b、c 设置为 final 。

  • a 之所以不采用 final 修饰,因为它是全局变量,生命周期是随着类的结束而结束。而类的生命周期肯定大于匿名内部类。


静态内部类

1.基本概念

静态内部类也是定义在一个类里面的类,只不过在类的前面多了一个关键字static

静态内部类和静态成员变量其实具有相同的特点:

  • 它只有类有关,与对象无关。因此可以在没有外部类对象情况下,创建静态内部类。

  • 不能访问外部类的非静态成员或方法


2.实例探究

  • 内部静态类定义:

public class Outter {
    int a = 5;    static int b = 500;    // 静态内部类
    static class Inner {        public Inner() {            // 只能访问外部类的静态成员
            System.out.println(b);
        }
    }
}
  • 静态内部类调用:

// 静态内部类的调用不依赖外部类对象Outter.Inner inner= new Outter.Inner();

接口内部类

1.基本概念

接口内部类,顾名思义就是在接口内定义的类。


2.实例探究

  • 接口内部类定义:

public interface People{
    class Man {        public void print() {
            System.out.println("man.print()...");
        }
    }
}
  • 接口内部类调用:

People.Man  man = new People.Man();

 以上就是04.Java 基础 - 类的内容,更多相关内容请关注PHP中文网(www.php.cn)!


声明:
本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系admin@php.cn