Java学习笔记三（面向对象和静态）_seat java 含义-优快云博客

本文详细解读了面向对象编程的关键概念，包括类与对象的关系、构造方法、访问权限、继承、多态、抽象与接口，以及内存分析。特别强调了类与对象的实现、构造方法的使用和静态成员的区别。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

0. 面向对象概述

1. 类与对象

2. 构造方法

3. 访问权限

4. 继承

5. 多态（！！！）

6. 抽象和接口

7. 内存分析

面向过程：侧重过程。

优点：逻辑简单

缺点：对大型项目而言，维护性很差。

面向对象：侧重对象。只关注对象，不关注具体实现过程。

优点：可扩展性很强，维护成本低。

缺点：对新手而言，思维转变较难。

由于有C++面向对象编程基础，所以较基础的细碎知识点不再赘述，只关注需要注意的点以及与C++语法有区别的地方。

1. 类与对象

造车：

1. 画图纸

a. 定义车的属性信息： color, speed, seat

b. 定义车的动作： run

2. 拿着图纸找工厂生产车

面向对象：

类：即图纸。

属性：这一类事物所具有的共同属性。

动作：这一类事物共同能执行的功能。

对象：使用类创建的具体某个东西。（类的对象实例化）

类的实现

1. 类使用 class 定义

2. 属性：成员变量来描述，直接写在类中（注意成员变量和局部变量）

3. 成员方法。不写 static 就是成员方法

public class Car {
    // 成员变量
    String color; // 颜色
    int speed; // 速度
    int seat; // 座位

    //成员方法
    public void run(){
        System.out.println("车启动");
    }

    public static void main(String[] args) {
        int a = 10;  // 写在方法里的变量， 局部变量

        // 创建对象（类的实例化）
        // 在面向对象世界中，这种变量类型被称为 引用
        // java中有两种数据类型：1.基本数据类型   2.引用数据类型 String、我们自己创建的类
        Car c = new Car();
        // 让车启动
        // 调用类的成员方法： 对象.方法() 或  引用.方法()
        c.run();

        c.color = "绿色";
        c.speed = 120;
        c.seat = 3;

        System.out.println(c.color);
    }
}

this关键字

public class Car {
    // 成员变量
    String color; // 颜色
    int speed; // 速度
    int seat; // 座位

    //成员方法
    public void run(){
      // 变量访问顺序： 1.先找方法内局部变量 2.再找类中this成员变量 3. 最后全局变量        
        System.out.println(color);

        System.out.println(this.seat);
        System.out.println(this.speed);
    }

    public static void main(String[] args) {
        int a = 10;  // 写在方法里的变量， 局部变量

        // 创建对象（类的实例化）
        // 在面向对象世界中，这种变量类型被称为 引用
        // java中有两种数据类型：
        //        1.基本数据类型   2.引用数据类型 String、我们自己创建的类
        Car c = new Car();

        c.color = "绿色";
        c.speed = 120;
        c.seat = 3;
        // 让车启动
        // 调用类的成员方法： 对象.方法() 或  引用.方法()
        c.run();

    }
}

this 可用来区分同名的成员变量和局部变量。

2. 构造方法

创建对象时，自动调用的方法。

public 类名( 传参 ){

}

注意：

1. 无返回值

2. new时自动调用

3. java会自动赠送构造方法。但若自己定义了构造方法，则java不再赠送。

4. 构造方法可重载。

public class Car2 {
    String color;
    int speed = 80;
    int seat = 5;
    public Car2(String color, int speed ){
        this.color = color;
        this.speed = speed;
    }
    public Car2(String color, int speed, int seat){
        this(color,speed);  // this()，可调用当前类中其他构造函数
        this.seat = seat;
    }

    public void run(){
        System.out.println(this.color+"色的车可启动");
        System.out.println(this.speed);
        System.out.println(this.seat);
    }
    public static void main(String[] args) {
        Car2 c1 = new Car2("绿",120);
        Car2 c2 = new Car2("红",180,6);

        c1.run();
        c2.run();
    }
}
/**
 * 运行结果：
 *   绿色的车可启动
 *   120
 *   5
 *   红色的车可启动
 *   180
 *   6
 */

3. static静态

在类中，使用 static 修饰符修饰的属性（成员变量）称为静态变量，也可以称为类变量，常量称为静态常量，方法称为静态方法或类方法，它们统称为静态成员，归整个类所有。

静态成员不依赖于类的特定实例，被类的所有实例共享，就是说 static 修饰的方法或者变量不需要依赖于对象来进行访问，只要这个类被加载，java就可以根据类名找到它们。

创建对象的过程：

1. 静态构造器

2. 通用构造器

3. 构造方法->创建对象

public class Test {
    String name;
//    public static void chi(){
//        System.out.println(this.name);  //不允许这样做
//    }
    {
        System.out.println("通用构造器");
    }
    static {
        System.out.println("静态构造器");
    }
    public Test(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        new Test();
    }
}

运行结果

静态构造器
通用构造器
构造方法

调用静态成员的语法形式如下：

类名.静态成员;

注意：

静态方法不能调用非静态成员，编译会报错。
this和super两个关键字不能在静态上下文中使用。
运行时，Java只为静态变量分配一次内存，在加载类的过程中完成静态变量的内存分配。
在类的内部，可以在任何方法内直接访问静态变量。
在其他类中，可以通过类名访问该类中的静态变量。
静态变量可以被类的所有实例共享

public class StaticVar {
    public static String str1 = "Hello";
    public static void main(String[] args) {
        String str2 = "World!";
        // 直接访问str1
        String accessVar1 = str1+str2;
        System.out.println("第 1 次访问静态变量，结果为："+accessVar1);
        // 通过类名访问str1
        String accessVar2 = StaticVar.str1+str2;
        System.out.println("第 2 次访问静态变量，结果为："+accessVar2);
        // 通过对象svt1访问str1
        StaticVar svt1 = new StaticVar();
        svt1.str1 = svt1.str1+str2;
        String accessVar3 = svt1.str1;
        System.out.println("第3次访向静态变量，结果为："+accessVar3);
        // 通过对象svt2访问str1
        StaticVar svt2 = new StaticVar();
        String accessVar4 = svt2.str1+str2;
        System.out.println("第 4 次访问静态变量，结果为："+accessVar4);
    }
}

运行结果：

第 1 次访问静态变量，结果为：HelloWorld!
第 2 次访问静态变量，结果为：HelloWorld!
第 3 次访向静态变量，结果为：HelloWorld!
第 4 次访问静态变量，结果为：HelloWorld!World!

由第4次访问，可以看出svt1和svt2共享str1。

静态方法

静态方法不需要通过它所属的类的任何实例就可以被调用，因此在静态方法中不能使用 this 关键字，也不能直接访问所属类的实例变量和实例方法，但是可以直接访问所属类的静态变量和静态方法。另外，和 this 关键字一样，super 关键字也与类的特定实例相关，所以在静态方法中也不能使用 super 关键字。
在实例方法中可以直接访问所属类的静态变量、静态方法、实例变量和实例方法。

public class StaticMethod {
    public static int count = 1;    // 定义静态变量count
    public int method1() {    
        // 实例方法method1
        count++;    // 访问静态变量count并赋值
        System.out.println("在静态方法 method1()中的 count="+count);    // 打印count
        return count;
    }
    public static int method2() {    
        // 静态方法method2
        count += count;    // 访问静态变量count并赋值
        System.out.println("在静态方法 method2()中的 count="+count);    // 打印count
        return count;
    }
    public static void PrintCount() {    
        // 静态方法PrintCount
        count += 2;
        System.out.println("在静态方法 PrintCount()中的 count="+count);    // 打印count
    }
    public static void main(String[] args) {
        StaticMethod sft = new StaticMethod();
        // 通过实例对象调用实例方法
        System.out.println("method1() 方法返回值 intro1="+sft.method1());
        // 直接调用静态方法
        System.out.println("method2() 方法返回值 intro1="+method2());
        // 通过类名调用静态方法，打印 count
        StaticMethod.PrintCount();
    }
}

运行结果为：

在静态方法 method1()中的 count=2
method1() 方法返回值 intro1=2
在静态方法 method2()中的 count=4
method2() 方法返回值 intro1=4
在静态方法 PrintCount()中的 count=6

在该程序中，静态变量 count 作为实例之间的共享数据，因此在不同的方法中调用 count，值是不一样的。从该程序中可以看出，在静态方法 method1() 和 PrintCount() 中是不可以调用非静态方法 method1() 的，而在 method1() 方法中可以调用静态方法 method2() 和 PrintCount()。

在访问非静态方法时，需要通过实例对象来访问，而在访问静态方法时，可以直接访问，也可以通过类名来访问，还可以通过实例化对象来访问。

静态代码块

静态代码块指 Java 类中的 static{ } 代码块，主要用于初始化类，为类的静态变量赋初始值，提升程序性能。

静态代码块的特点如下：

静态代码块类似于一个方法，但它不可以存在于任何方法体中。
静态代码块可以置于类中的任何地方，类中可以有多个静态初始化块。
Java 虚拟机在加载类时执行静态代码块，所以很多时候会将一些只需要进行一次的初始化操作都放在 static 代码块中进行。
如果类中包含多个静态代码块，则 Java 虚拟机将按它们在类中出现的顺序依次执行它们，每个静态代码块只会被执行一次。
静态代码块与静态方法一样，不能直接访问类的实例变量和实例方法，而需要通过类的实例对象来访问。

编写一个 Java 类，在类中定义一个静态变量，然后使用静态代码块修改静态变量的值。最后在 main() 方法中进行测试和输出。

public class StaticCode {
    public static int count = 0;
    {
        count++;
        System.out.println("非静态代码块 count=" + count);
    }
    static {
        count++;
        System.out.println("静态代码块1 count=" + count);
    }
    static {
        count++;
        System.out.println("静态代码块2 count=" + count);
    }

    public static void main(String[] args) {
        System.out.println("*************** StaticCode1 执行 ***************");
        StaticCode sct1 = new StaticCode();
        System.out.println("*************** StaticCode2 执行 ***************");
        StaticCode sct2 = new StaticCode();
    }
}

如上述示例，为了说明静态代码块只被执行一次，特地添加了非静态代码块作为对比，并在主方法中创建了两个类的实例对象。上述示例的执行结果为：

静态代码块1 count=1
静态代码块2 count=2
*************** StaticCode1 执行 ***************
非静态代码块 count=3
*************** StaticCode2 执行 ***************
非静态代码块 count=4

上述代码中 { } 代码块为非静态代码块，非静态代码块是在创建对象时自动执行的代码，不创建对象不执行该类的非静态代码块。代码域中定义的变量都是局部的，只有域中的代码可以调用。