四、 java的对象和类

四、 java的对象和类

• 对象（Object）：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
• 类（class）：类是现实生活的模板，它描述一类对象的行为和状态，可以看成是创建 Java 对象的模板。比如鸟类。

下图中汽车为类（class），而具体的每辆车为该汽车类的对象（object），对象包含了汽车的颜色、品牌、名称等。

java的类

通过上图创建一个简单的类来理解下 Java 中类的定义：

public class Dog {
    String breed;
    int size;
    String colour;
    int age;
 
    void eat() {
    }
 
    void run() {
    }
 
    void sleep(){
    }
 
    void name(){
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

一个类可以包含以下类型变量：

• 局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。如下代码所示，name就是局部变量。

void eat() {
 String name = null；
    }
1
2
3

• 成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。如下代码所示，breed、size、colour、age都是成员变量。

public class Dog {
    String breed;
    int size;
    String colour;
    int age;
}
1
2
3
4
5
6

• 类变量：类变量也声明在类中，方法体之外，但必须声明为 static 类型。如下代码所示，sql就是类变量。

public class Dog {
    private static final String sql = "SELECT_NAME_FROM_TABLE";
}
1
2
3

一个类可以拥有多个方法，在上面的例子中：eat()、run()、sleep() 和 name() 都是 Dog 类的方法。

构造方法

每个类都有构造方法。如果没有定义构造方法，java编译器会为该类提供一个默认的无参构造方法。

构造方法的作用：创建java对象（实例）。

构造方法分为两类：

1. 有参构造方法
2. 无参构造方法

构造方法特征：方法名和类名相同，没有返回值，也没有void关键字。一个类可以有多个构造方法。

代码示例：

public class Dog {

    String name;

//无参构造方法
    public Dog() {
    }

//有参构造方法
   public Dog(String name) {
        this.name = name;
        System.out.println("小狗的品种是："+name);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

创建对象

实例化：使用关键字 new 来创建一个对象。

public static void main(String[] args) {
        Dog dog = new Dog("中华田园犬");//调用有参构造方法
        Dog dog2 = new Dog();//调用无参构造方法
    }
1
2
3
4

执行main方法控制台打印结果：

小狗的品种是：中华田园犬
1

访问类中的变量和方法

类中的一切成员变量和方法都是通过对象来访问调用。

实例代码：

public class Dog {

    String name;

    public Dog() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

public static void main(String[] args) {
        Dog dog = new Dog();//调用无参构造方法创建对象
        dog.setName("中华田园犬");//通过对象实力调用set方法
        dog.getName();//通过对象实力调用get方法
        System.out.println("打印结果："+dog.name);//访问成员变量
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

打印结果：

java内部类

内部类即Java 一个类中可以嵌套另外一个类，语法格式如下：

class OuterClass {   // 外部类
    // ...
    class InnerClass { // 嵌套类，或称为内部类
        // ...
    }
}
1
2
3
4
5
6

要访问内部类，可以通过创建外部类的对象，然后创建内部类的对象来实现。

嵌套类有两种类型：

1. 非静态内部类
2. 静态内部类

非静态内部类

非静态内部类是一个类中嵌套着另外一个类。 它有访问外部类成员的权限， 通常被称为内部类。

由于内部类嵌套在外部类中，因此必须首先实例化外部类，然后创建内部类的对象来实现。

示例代码：

class OuterClass {
    int out = 8;

    class InnerClass {
        int inner = 6;
    }
}

    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();
        System.out.println("外部类的成员变量是："+outerClass.out+" ,内部类的成员变量是："+innerClass.inner);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13

控制台打印结果：

外部类的成员变量是：8 ,内部类的成员变量是：6
1

私有的内部类

内部类可以使用 private 或 protected 来修饰，如果你不希望内部类被外部类访问可以使用 private 修饰符：

class OuterClass {
    int out = 8;

    private class InnerClass {
        int inner = 6;
    }
}
1
2
3
4
5
6
7

由于内部类被private修饰，外部类无法访问，所以main方法创建实例报错：

静态内部类

静态内部类可以使用 static 关键字定义，静态内部类我们不需要创建外部类来访问，可以直接访问它：

class OuterClass {
    int out = 8;

    static class InnerClass {
        int inner = 6;
    }

public static void main(String[] args) {
        OuterClass.InnerClass innerClass = new OuterClass.InnerClass();
        System.out.println("内部类的成员变量是：" + innerClass.inner);
    }
1
2
3
4
5
6
7
8
9
10
11

打印结果：

内部类的成员变量是：6
1

注意：静态内部类无法访问外部类的成员。

从内部类访问外部类成员

内部类一个高级的用法就是可以访问外部类的属性和方法：

class OuterClass {
    int out = 8;

    class InnerClass {
        public int myInnerMethod() {
            return out;
        }
    }

public static void main(String[] args) {
        OuterClass myOuter = new OuterClass();
        OuterClass.InnerClass myInner = myOuter.new InnerClass();
        System.out.println(myInner.myInnerMethod());
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

打印结果：

8
1

java匿名类

什么是匿名类？

Java 中可以实现一个类中包含另外一个类，且不需要提供任何的类名直接实例化。

匿名类是不能有名字的类，它们不能被引用，只能在创建时用 new 语句来声明它们。

匿名类语法格式：

class outerClass {

    // 定义一个匿名类
    object1 = new Type(parameterList) {
         // 匿名类代码
    };
}
1
2
3
4
5
6
7

以上的代码创建了一个匿名类对象 object1，匿名类是表达式形式定义的，所以末尾以分号 ; 来结束。

匿名类通常继承一个父类或实现一个接口。

匿名类继承一个父类

以下实例中，创建了 Animal 类，该类只有一个方法 show()，AnonymousDemo 类继承了 Animal 类并重写了 Animal 类的 show() 方法:

class Animal {
 public void show() {
  System.out.println("在 Animal 类内部");
 }
}

public class AnonymousDemo {

    public void createClass() {
        Animal animal = new Animal() {
            public void show() {
                System.out.println("在匿名类内部。");
            }
        };
        animal.show();
    }
}

public static void main(String[] args) {
        AnonymousDemo anonymousDemo = new AnonymousDemo();
        anonymousDemo.createClass();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

打印结果：

在匿名类内部。
1

匿名类实现一个接口

interface Animal {
 void show();
}

public class AnonymousDemo {

    public void createClass() {
        Animal animal = new Animal() {
            public void show() {
                System.out.println("在匿名类内部。");
            }
        };
        animal.show();
    }
}

public static void main(String[] args) {
        AnonymousDemo anonymousDemo = new AnonymousDemo();
        anonymousDemo.createClass();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

打印结果：

在匿名类内部。
1

拓展连接：java具体类