类和对象（二）-阿里云开发者社区

一：封装

面对对象程序的三大特性：封装，继承，多态。

1：什么是封装？

封装就是将类的实现细节进行了隐藏，对外只提供一些接口。

2：为什么要封装？

为了安全考虑。

3：访问限定符：

Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认识，而访问权限用来控制方法或者字段能否直接在类外使用。

public：可以理解为一个人的外貌特征，谁都可以看的到；

default：包访问权限，只有在同一个包中才可以使用。对于自己家族中（同一个包中）不是什么秘密，对于其他人来说就是隐私了。

private：只能在同一个类中使用。

protected:在同一个包中，以及不同包的子类中可以使用。

一般我们类的成员变量我们写成private修饰，成员方法用public修饰，可以根据具体的情景来确定使用什么限定符。

举个例子看一下吧！

class Student{
    private String name;
    private int age;
    private String classroom;
    //构造方法
    public Student(String name, int age, String classroom) {
        this.name = name;
        this.age = age;
        this.classroom = classroom;
    }
   //公开的接口，获得成员变量name
    public String getName() {
        return name;
    }
    //公开的接口，设置成员变量name
    public void setName(String name) {
        this.name = name;
    }
    //公开的接口，获得成员变量age
    public int getAge() {
        return age;
    }
    //公开的接口，设置成员变量age
    public void setAge(int age) {
        this.age = age;
    }
    //公开的接口，获得成员变量classroom
    public String getClassroom() {
        return classroom;
    }
    //公开的接口，设置成员变量classroom
    public void setClassroom(String classroom) {
        this.classroom = classroom;
    }
}
public class Test {
    public static void main(String[] args) {
    Student student=new Student("张三",20,"1770");
    }
}

二：static成员：

先看个例子：

class Student{
    private String name;
    private int age;
    private String classroom;
    //构造方法
    public Student(String name, int age, String classroom) {
        this.name = name;
        this.age = age;
        this.classroom = classroom;
    }
   //公开的接口，获得成员变量name
    public String getName() {
        return name;
    }
    //公开的接口，设置成员变量name
    public void setName(String name) {
        this.name = name;
    }
    //公开的接口，获得成员变量age
    public int getAge() {
        return age;
    }
    //公开的接口，设置成员变量age
    public void setAge(int age) {
        this.age = age;
    }
    //公开的接口，获得成员变量classroom
    public String getClassroom() {
        return classroom;
    }
    //公开的接口，设置成员变量classroom
    public void setClassroom(String classroom) {
        this.classroom = classroom;
    }
    @Override
    public String toString() {
        return "姓名:"+this.name+" 年龄："+age+" 班级："+classroom;
    }
}
public class Test {
    public static void main(String[] args) {
    Student student1=new Student("张三",20,"1770");
    Student student2=new Student("李四",21,"1770");
    Student student3=new Student("王五",19,"1770");
        System.out.println(student1.toString());
        System.out.println(student2.toString());
        System.out.println(student3.toString());
    }
}

我们发现这三个同学的上课班级都是相同的，都是1770，而在Student类中定义的成员变量，每个对象都会包含一份，因为这些需要描述一个具体的学生，而这个教室并不需要每个学生来存储一份，而是所有的学生共享。

在Java中，被static修饰的成员，称为静态成员，也可以称为类成员，其不属于某个具体的对象，而是所有对象共享的。

1：static修饰成员变量

1：static修饰的成员变量称为静态成员变量，静态成员变量的最大特征就是不属于某个具体的对象，是所有对象所共享的。

2：既可以通过类名访问，又可以通过对象访问，但更推荐使用类名访问，因为static修饰的成员变量是不属于某个对象的，而是属于类的。

3：static修饰的成员变量存储在方法区中；

4：生命周期伴随类的一生，随着类的加载而创建，随着类的卸载而销毁。

static修饰成员变量举例：

class Student{
    private String name;
    private int age;
    private static String classroom="1770";
    //构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
   //公开的接口，获得成员变量name
    public String getName() {
        return name;
    }
    //公开的接口，设置成员变量name
    public void setName(String name) {
        this.name = name;
    }
    //公开的接口，获得成员变量age
    public int getAge() {
        return age;
    }
    //公开的接口，设置成员变量age
    public void setAge(int age) {
        this.age = age;
    }
    //公开的接口，获得成员变量classroom
    public String getClassroom() {
        return classroom;
    }
    //公开的接口，设置成员变量classroom
    public void setClassroom(String classroom) {
        this.classroom = classroom;
    }
    @Override
    public String toString() {
        return "姓名:"+this.name+" 年龄："+age+" 班级："+classroom;
    }
}
public class Test {
    public static void main(String[] args) {
    Student student1=new Student("张三",20);
    Student student2=new Student("李四",21);
    Student student3=new Student("王五",19);
        System.out.println(student1.toString());
        System.out.println(student2.toString());
        System.out.println(student3.toString());
    }
}

class Student{
    private String name;
    private int age;
    public  static String classroom;
    //构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
   //公开的接口，获得成员变量name
    public String getName() {
        return name;
    }
    //公开的接口，设置成员变量name
    public void setName(String name) {
        this.name = name;
    }
    //公开的接口，获得成员变量age
    public int getAge() {
        return age;
    }
    //公开的接口，设置成员变量age
    public void setAge(int age) {
        this.age = age;
    }
    //公开的接口，获得成员变量classroom
    public String getClassroom() {
        return classroom;
    }
    //公开的接口，设置成员变量classroom
    public void setClassroom(String classroom) {
        this.classroom = classroom;
    }
    @Override
    public String toString() {
        return "姓名:"+this.name+" 年龄："+age+" 班级："+classroom;
    }
}
public class Test {
    public static void main(String[] args) {
    Student student1=new Student("张三",20);
    Student student2=new Student("李四",21);
    Student student3=new Student("王五",19);
    Student.classroom="1770";
    System.out.println(student1.toString());
    System.out.println(student2.toString());
    System.out.println(student3.toString());
    }
}

2：static修饰成员方法

1：被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。

2：可以通过类名来调用，也可以通过对象调用，但更推荐类名调用。

3：不可以在静态方法中访问任何非静态的成员变，不可以在静态方法中调用非静态的方法；

4：可以在非静态的方法中调用静态的成员变量和静态的成员方法。

5：在静态方法中不可以使用this引用。

class Student{
    private String name;
    private int age;
    private static String classroom;
    //构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public static String getClassroom(){
       return classroom;
    }
    public static void setClassroom(String classroom) {
        Student.classroom = classroom;
    }
    //公开的接口，获得成员变量name
    public String getName() {
        return name;
    }
    //公开的接口，设置成员变量name
    public void setName(String name) {
        this.name = name;
    }
    //公开的接口，获得成员变量age
    public int getAge() {
        return age;
    }
    //公开的接口，设置成员变量age
    public void setAge(int age) {
        this.age = age;
    }
    //公开的接口，获得成员变量classroom
    @Override
    public String toString() {
        return "姓名:"+this.name+" 年龄："+age+" 班级："+classroom;
    }
}
public class Test {
    public static void main(String[] args) {
    Student student1=new Student("张三",20);
    Student student2=new Student("李四",21);
    Student student3=new Student("王五",19);
    Student.setClassroom("1770");
    System.out.println(student1.toString());
    System.out.println(student2.toString());
    System.out.println(student3.toString());
    }
}

3：类的成员变量

类的成员变量分为两种：

1：静态成员变量

2:非静态成员变量/普通成员变量

在非静态的成员方法中可以访问静态的成员变量和静态的成员方法。

1:静态成员变量

1：静态成员变量是属于类的，不属于对象，只有一份

2：通常使用类名来访问

3：静态的成员变量随着类被加载而加载，随着类的销毁而销毁。

2：非静态成员变量/普通成员变量

1：属于对象的，每实例化一个对象，都会有一个对应的非静态成员变量，每个对象都有。

2:通过对象来访问。

三：代码块

使用{}定义的代码称为代码块。根据代码块定义的位置以及关键字又分为：

1：普通代码块

2：构造代码块/实例代码块

3：静态代码块

1：普通代码块

普通代码块是定义在方法中的代码块，一般不使用，

public class Test{
    public static void main(String[] args) {
        {//普通代码块
            System.out.println("这是普通代码块");
            System.out.println("哈哈");
        }
    }
}

2:构造代码块/实例代码块

定义在类中的代码块称为构造代码块，也叫做：实例代码块，一般用于初始化实例成员变量。

仍是学生类：

//构造代码块，实例代码块
    {
        this.name="张三";
        this.age=19;
    }

3：静态代码块

用static修饰的代码块称为静态代码块，一般用于初始化静态的成员变量

//静态代码块
 static{
        classroom="1770";
    }

静态代码块不依赖与对象，随着类的加载而加载：

class Student{
    private String name;
    private int age;
    public  static String classroom;
    //构造方法
    public Student(String name, int age) {
        System.out.println("这是构造方法");
    }
    //构造代码块，实例代码块
    {
        System.out.println("这是构造代码块");
    }
    static{
        classroom="1770";
        System.out.println("这是静态代码块");
    }
}
public class Test{
    public static void main(String[] args) {
        //这里我们没有创建对象
        System.out.println(Student.classroom);
    }
}

注意：

1：不管生成多少个对象，静态代码块只会执行一次。

2：静态成员变量是类的属性，类在加载的时候完成初始化。

3：如果一个类中包含多个静态代码块，在程序执行时，程序会依次执行。

4：实例代码块只有在创建对象的时候才会执行，和构造方法一样，创建一次对象，执行一次。

5：先执行静态代码块，再执行实例代码块，再执行构造方法。但静态代码块只会执行一次。

class Student{
    private String name;
    private int age;
    public  static String classroom;
    //构造方法
    public Student(String name, int age) {
        System.out.println("这是构造方法");
    }
    //构造代码块，实例代码块
    {
        System.out.println("这是构造代码块");
    }
    static{
        classroom="1770";
        System.out.println("这是静态代码块");
    }
}
public class Test{
    public static void main(String[] args) {
        Student student1=new Student("张三",19);
        Student student2=new Student("李四",20);
        // 创建了两个对象实例代码块和构造方法执行了两次，
        // 而静态代码块只会执行一次
    }
}

类和对象（二）

一：封装

1：什么是封装？

2：为什么要封装？

3：访问限定符：

二：static成员：

1：static修饰成员变量

2：static修饰成员方法

3：类的成员变量

1:静态成员变量

2：非静态成员变量/普通成员变量

三：代码块

1：普通代码块

2:构造代码块/实例代码块

3：静态代码块

热门文章

最新文章

相关电子书

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

训练营

直播

乘风者计划

下载

镜像站

技术资料

类和对象（二）

一：封装

1：什么是封装？

2：为什么要封装？

3：访问限定符：

二：static成员：

1：static修饰成员变量

2：static修饰成员方法

3：类的成员变量

1:静态成员变量

2：非静态成员变量/普通成员变量

三：代码块

1：普通代码块

2:构造代码块/实例代码块

3：静态代码块

热门文章

最新文章

相关电子书