面向对象编程

  • static关键字
  • static变量
  • static方法(静态方法)
  • 代码块与static代码块
  • static的优缺点
  • 封装

static关键字

static是Java中的一个关键字,单词本身是静态的含义。一个类的成员包括变量、方法、构造方法、代码块和内部类,static可以修饰除了构造方法以外的所有成员。

使用static修饰的成员成为静态成员,是属于某个类的;而不使用static修饰的成员成为实例成员,是属于类的每个对象的。

static变量

在类中,用static声明的成员变量为静态成员变量,也称为类变量。 类变量的生命周期和类相同,在整个应用程序执行期间都有效。它有如下特点:

  • 为该类的公用变量,属于类,被该类的共享,在类被载入时被显式初始化。
  • 对于该类的所有对象来说,static成员变量只有一份。被该类的所有对象共享!
  • 一般用“类名.类属性/方法”来调用。(也可以通过对象引用或类名(不需要实例化)访问静态成员。)
  • 在static方法中不可直接访问非static的成员。

static修饰的成员变量叫做静态成员变量;没有static修饰的成员变量叫做实例成员变量。两者区别:

静态成员变量

实例成员变量

存储份数

一份

一个对象一份

存储位置

存储在方法区中

存储在堆内存上

内存分配空间的时间不同

第一次加载类的时候

创建对象的时候

生命周期

静态变量和类的生命周期相同

实例成员变量的生命周期和所属对象相同

特性

被当前类对象共享

每个对象独有的

调用方式

可以使用[对象名].[属性名]访问 ,但推荐使用[类名].[属性名]的方式访问

只能有[对象名].[属性名]的形式访问

static方法(静态方法)

static修饰的方法叫做静态成员方法;没有static修饰的方法叫做实例成员方法。
静态方法的作用:访问static变量和static方法。

静态成员方法

实例成员方法

变量使用

只能直接使用静态成员变量

既可以直接使用静态成员变量 ,也可以直接使用实例成员变量

方法调用

可以使用[对象名].[方法名]方式调用;更推荐使用[类名].[方法名]方式调用

只能使用[对象名].[方法名]方式调用

this关键字

不能使用

可以使用

调用其他方法

只能直接调用其他静态成员方法

既能直接调用其他静态成员方法,也可以直接调用其他实例方法

变量初始化

在构造方法中,往往不会对静态成员变量进行初始化

在构造方法中,往往只会对实例成员变量进行初始化

静态方法中不可以访问非静态变量
静态方法中不可以访问非静态方法
静态方法中不可以访问this

理解:加载类的时候就加载静态变量和静态方法,而this代表的是当前对象,此时可能还没有创建对象,所以非静态变量和非静态的方法还没有分配空间,无法访问。

非静态方法中可以访问静态变量
非静态方法中可以访问静态方法

理解:加载类的时候就已经加载静态变量和静态方法,创建对象后,非静态变量和非静态的方法才分配空间,此时静态变量和静态方法已经存在,可以访问。

代码块与static代码块

代码块

  • 普通代码块 一般用于帮助我们初始化一些实例成员变量
  • 在一个类中可以有多个普通代码块
  • 每次执行构造方法之前,普通代码块都会执行一次,每实例化对象一次,普通代码块都会执行一次

静态代码块

  • 静态代码块 一般用于初始化静态成员变量的
  • 在一个类中可以有多个静态代码块
  • 类加载进入内存的之后,静态代码块执行一次

静态代码块,非静态代码块,构造方法都是完成初始化操作,但调用时机不同:
静态代码块在类加载的时候调用
非静态代码块在堆内存创建对象之前
构造方法在创建对象时调用

static的优缺点

优点:
不需要在进行实例化。静态变量的值,直接赋新值即可,不需要参数传递,之后可以直接进行参数引用即可;静态方法可以直接通过"类名.方法"的形式进行方法调用。通常方法被多次调用,并且方法中没有动态方法引用的时候使用比较方便。
缺点:
初始化加载到内存,如果后续没被引用,加大了内存负担和程序运行负担,影响程序运行效率(一般很小),并且静态变量如果多处被引用赋值,很可能导致参数值混乱
如果从线程安全、性能、兼容性上来看 也是选用实例化方法为宜。

封装

封装(encapsulation)是面向对象三大特征之一。对于程序合理的封装让外部调用更加方便,更加利于写作。同时,对于实现者来说也更加容易修正和改版代码。

面向对象编程,语言的三大特征 封装 继承 多态
面向对象编程,语言的四大特征 封装 继承 多态 抽象

需要让用户知道的才暴露出来,不需要让用户知道的全部隐藏起来,这就是封装。说的专业一点,封装就是把对象的属性和操作结合为一个独立的整体,并尽可能隐藏对象的内部实现细节,仅仅对外公开使用的接口/方法。

我们程序设计要追求“高内聚,低耦合”。高内聚就是类的内部数据操作细节自己完成,不允许外部干涉;低耦合是仅暴露少量的方法给外部使用,尽量方便外部调用。

编程中封装的具体优点:

  • 提高代码的安全性。
  • 提高代码的复用性。
  • “高内聚”:封装细节,便于修改内部代码,提高可维护性。
  • “低耦合”:简化外部调用,便于调用者使用,便于扩展和协作。

如何对一个类进行封装处理
1.属性私有化:使用private访问修饰符修饰成员变量,private 修饰的类的成员只能在当前类内部使用
2.给属性提供公有的外界访问的方法 get set

public class Student {
    private static String Name;
    private String gender;
    private int age;
    private double score;
    private boolean pass;
    public Student(String gender, int age, double score, boolean pass) {
        this.gender = gender;
        this.age = age;
        this.score = score;
        this.pass = pass;
    }

    public Student() {
    }

    public static String getName() {    // 静态的属性,其对应的get和set方法也应该是静态的方法
        return Name;
    }

    public static void setName(String name) {
        Name = name;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    // 如果属性类型为boolean类型,其对应的get方法叫做 is...  set方法仍然是set...
    public boolean isPass() {    
        return pass;
    }

    public void setPass(boolean pass) {
        this.pass = pass;
    }
}