四、 java的对象和类

青旅半醒 2024-04-07 11:58 57阅读 0赞

## 四、 java的对象和类 ##

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

下图中汽车为类（class），而具体的每辆车为该汽车类的对象（object），对象包含了汽车的颜色、品牌、名称等。  
![在这里插入图片描述][7a37a05955054e918e6e185781fbf9e3.png]

### java的类 ###

![在这里插入图片描述][ca2b7fe24e0e4b79bf0ff404a29674a6.png]  
通过上图创建一个简单的类来理解下 Java 中类的定义：

public class Dog {
        
        String breed;
        int size;
        String colour;
        int age;
     
        void eat() {
        
        }
     
        void run() {
        
        }
     
        void sleep(){
        
        }
     
        void name(){
        
        }
    }

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

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

void eat() {
        
     String name = null；
        }

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

public class Dog {
        
        String breed;
        int size;
        String colour;
        int age;
    }

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

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

一个类可以拥有多个方法，在上面的例子中：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);
        }
    }

#### 创建对象 ####

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

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

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

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

### 访问类中的变量和方法 ###

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

实例代码：

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);//访问成员变量
        }
    }

打印结果：

![在这里插入图片描述][a10a87c50cad461fabcf343464640098.png]

### java内部类 ###

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

class OuterClass {
           // 外部类
        // ...
        class InnerClass {
         // 嵌套类，或称为内部类
            // ...
        }
    }

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

嵌套类有两种类型：

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);
        }

控制台打印结果：

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

#### 私有的内部类 ####

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

class OuterClass {
        
        int out = 8;
    
        private class InnerClass {
        
            int inner = 6;
        }
    }

由于内部类被private修饰，外部类无法访问，所以main方法创建实例报错：  
![在这里插入图片描述][0b5cf011069443368e34b3981ca73127.png]

#### 静态内部类 ####

静态内部类可以使用`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);
        }

打印结果：

内部类的成员变量是：6

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

#### 从内部类访问外部类成员 ####

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

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());
        }

打印结果：

### java匿名类 ###

**什么是匿名类？**

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

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

匿名类语法格式：

class outerClass {
        
    
        // 定义一个匿名类
        object1 = new Type(parameterList) {
        
             // 匿名类代码
        };
    }

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

匿名类通常继承一个父类或实现一个接口。  
![在这里插入图片描述][f699370ce0954c268f9cef14b2105fbe.png]

#### 匿名类继承一个父类 ####

以下实例中，创建了 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();
        }

打印结果：

在匿名类内部。

#### 匿名类实现一个接口 ####

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();
        }

打印结果：

在匿名类内部。

### 拓展连接：[java具体类][java] ###

[7a37a05955054e918e6e185781fbf9e3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/cff0d1ddec304fc588f5a1fc8a03b733.png
[ca2b7fe24e0e4b79bf0ff404a29674a6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/7ba05347494d40a1bd450679e68a0f48.png
[a10a87c50cad461fabcf343464640098.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/34d6c24de0fe4573b08c7f4eb2c66143.png
[0b5cf011069443368e34b3981ca73127.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/4a25fc386a9040568a746d936a0d0be8.png
[f699370ce0954c268f9cef14b2105fbe.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/2731229a6ab848d6a5e3ee1018f6e657.png
[java]: https://blog.csdn.net/m0_58680865/article/details/122178169