JAVASE——面向对象高级（一）

面向对象高级

一、静态

static关键字：可用于修饰成员变量，也可用于修饰成员方法。

1.1 修饰成员变量

  • 类变量：有static修饰，属于类，会被类的全部对象共享。

  • 实例变量（对象的变量）：无static修饰，属于每个对象。

image-20241029161725393

静态变量属于类，通过类名就能调用：类名.类变量名

实例变量属于对象，通过对象名才能调用：对象名.实例变量名

1.2 修饰成员变量的应用场景

在实际开发中，如果某个数据只需要一份，且希望能够被共享（访问、修改），则该数据可以定义成类变量来记住。

场景：类A统计创建了多少个对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class User {
    static int number;

    public User(){
        User.number++;
    }

    public static void main(String[] args) {
       
        for(int i =0; i<5; i++){
            new User();
        }

        System.out.println(User.number);
    }
}

1.3 修饰成员方法

  • 类方法：有static修饰的方法，属于类 类名.类方法名
  • 实例方法：无static修饰的方法，属于对象 对象名.实例变量名

  1. 类方法：static修饰的方法，可以被类名调用，是因为它是随着类的加载而加载的；所以类名直接就可以找到static修饰的方法

  2. 实例方法：非static修饰的方法，需要创建对象后才能调用，是因为实例方法中可能会访问实例变量，而实例变量需要创建对象后才存在。 所以实例方法，必须创建对象后才能调用。

1.4 static应用

  • 静态代码块：类加载时自动执行，由于类只会加载一次，所有静态代码块也只会执行一次。 可用于对类的初始化。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    public class Student {
        static int number = 80;
        static String name = "Wendy";
        // 静态代码块
        static {
            System.out.println("静态代码块已执行！");
            
        }

        public static void main(String[] args) {
            System.out.println(Student.number);
            System.out.println(Student.name);
        }

    }

    执行上面代码时，发现没有创建对象，静态代码块就已经执行了。

  • 实例代码块：每次创建对象时，执行实例代码块，并在构造器前执行。实例代码块的作用和构造器的作用是一样的，用来给对象初始化值

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    public class Student {
        int number;
        String name;
        {
            System.out.println("实例代码块已执行！");
            number = 20;
            name = "Wendy";


        }

        public Student(){
            System.out.println("无参构造器执行");
        }

        public Student(int number, String name){
            System.out.println("有参构造器执行");
            this.number = number;
            this.name = name;
        }



        public static void main(String[] args) {
            Student s1 = new Student();
            Student s2 = new Student(25, "MIKE");
            System.out.println(s1.number);
            System.out.println(s1.name);
            System.out.println(s2.number);
            System.out.println(s2.name);
        }

    }

    结果：

    image-20241029165429241

    实例代码块每次创建对象之前都会执行一次

二、继承

2.1 什么是继承

面向对象三大特征：继承、封装、多态

JAVA中提供了extends关键字，可以让一个类与另一个类建立起父子关系。

特点：子类可以继承父类的所有 非私有成员（变量、方法）

继承后对象的创建：子类的对象时由 父类、子类共同完成的。

2.2 继承的好处

减少重复代码的编写。

可以把重复的代码提取出来，作为父类，然后让其他类继承父类就可以了，这样可以提高代码的复用性。

2.3 权限修饰符

权限修饰符是用来限制类的成员（成员变量、成员方法、构造器…）能够被访问的范围。

1664012151488

2.4 单继承、Object

Java语言只支持单继承，不支持多继承，但是可以多层继承

Object类是Java中所有类的祖宗

2.5 方法重写 Override

当子类觉得父类方法不好用，或者无法满足父类需求时，子类可以重写一个方法名称、参数列表一样的方法，去覆盖父类的这个方法，这就是方法重写。

重写后，方法的访问遵循就近原则

注意：

  • 子类复写父类方法时，访问权限必须大于或者等于父类方法的权限，
  • 重写的方法返回值类型，必须与被重写的方法返回值类型一样，或者范围更小
  • 私有方法、静态方法不能被重写，如果重写会报错。

2.6 子类中访问成员的特点

在子类中访问其他成员（成员变量、成员方法），是依据就近原则的

如果子类和父类出现同名变量或者方法，优先使用子类的；此时如果一定要在子类中使用父类的成员，可以加this或者super进行区分。

2.7 子类访问构造器的特点

  • 子类中访问构造器的语法规则：首先，子类全部构造器，都会先调用父类构造器，再执行自己。

    1664160225526

  • 子类访问构造器的应用场景：如果不想使用默认的super()方式调用父类构造器，还可以手动使用super(参数)调用父类有参数构造器。

    1664163881728

  • 在本类中访问自己的构造方法：

    1
    2
    this(): 调用本类的空参数构造器
    this(参数): 调用本类有参数的构造器

  • 总结：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    访问本类成员：
    	this.成员变量	//访问本类成员变量
    	this.成员方法	//调用本类成员方法
    	this()		   //调用本类空参数构造器
        this(参数)	  //调用本类有参数构造器
    	
    访问父类成员：
    	super.成员变量	//访问父类成员变量
    	super.成员方法	//调用父类成员方法
    	super()		   //调用父类空参数构造器
        super(参数)	  //调用父类有参数构造器
        
    注意：this和super访问构造方法，只能用到构造方法的第一句，否则会报错。
JAVASE——面向对象高级（一）
https://wendyflv.github.io/2024/10/29/JAVASE——面向对象高级（一）/
作者
Wendyflv
发布于
2024年10月29日
许可协议