本文共 7189 字，大约阅读时间需要 23 分钟。

封装(private)

封装概述：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

封装的好处

• 隐藏实现细节，提供公共的访问方式

• 提高了代码的复用性

• 提高安全性。

封装原则

• 将不需要对外提供的内容都隐藏起来。

• 把属性隐藏，提供公共方法对其访问。

private关键字

• 是一个权限修饰符。

• 可以修饰成员(成员变量和成员方法)

• 被private修饰的成员只在本类中才能访问。

private最常见的应用

• 把成员变量用private修饰

• 提供对应的getXxx()和setXxx()方法

一个标准的案例的使用

/**    封装和private的应用：        A:把成员变量用private修饰        B:提高对应的getXxx()和setXxx()方法*///定义学生类class Student {    //姓名    private String name;    //年龄    private int age;    //姓名获取值    public String getName() {        return name;    }    //姓名设置值    public void setName(String n) {        name = n;    }    //年龄获取值    public int getAge() {        return age;    }    //年龄赋值    public void setAge(int a) {        age = a;    }}//测试类class StudentTest {    public static void main(String[] args) {        //创建学生对象        Student s = new Student();        //使用成员变量        //错误：被私有修饰了，外界不能直接访问了        //System.out.println(s.name+"---"+s.age);        System.out.println(s.getName()+"---"+s.getAge());        //给成员变量赋值        //s.name = "林青霞";        //s.age = 27;        //通过方法给赋值        s.setName("林青霞");        s.setAge(27);        System.out.println(s.getName()+"---"+s.getAge());    }}

运行结果：

this关键字

this代表其所在函数所属对象的引用。换言之，this代本类对象的引用。

当成员变量和局部变量重名，可以用关键字this来区分，this就是所在函数所属对象的引用。

简单说，哪个对象调用了this所在的函数，this就代表哪个对象。一般方法调用默认加this。（方法被哪个对象调用，this就代表那个对象）

什么时候使用this呢?

• 局部变量隐藏成员变量

• 其他用法后面和super一起讲解

/**    我们曾经曰：起名字要做到见名知意。    this:是当前类的对象引用。简单的记，它就代表当前类的一个对象。        注意：谁调用这个方法，在该方法内部的this就代表谁。    this的场景：        解决局部变量隐藏成员变量    this:哪个对象调用那个方法，this就代表那个对象*/class Student {    private String name;    private int age;    public String getName() {        return name; //这里其实是隐含了this    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }}class StudentTest2 {    public static void main(String[] args) {        //创建一个对象        Student s1 = new Student();        s1.setName("林青霞");        s1.setAge(27);        System.out.println(s1.getName()+"---"+s1.getAge());        //创建第二个对象        Student s2 = new Student();        s2.setName("刘意");        s2.setAge(30);        System.out.println(s2.getName()+"---"+s2.getAge());    }}

运行结果：

this关键字的内存图解：

构造方法

构造方法作用概述：给对象的数据进行初始化

构造方法格式

• 方法名与类名相同

• 没有返回值类型，连void都没有

• 没有具体的返回值

构造方法注意事项

• 如果你不提供构造方法，系统会给出默认构造方法

• 如果你提供了构造方法，系统将不再提供

• 构造方法也是可以重载的

给成员变量赋值有两种方式

• setXxx()

• 构造方法

PS：

1. 一般函数和构造函数什么区别呢？

构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。

构造函数：对象创建时，会调用并且只调用一次。

1. 创建对象都必须要通过构造函数初始化。

一个类中如果没有定义过构造函数，那么该类中会有一个默认的空参数构造函数。

如果在类中定义了指定的构造函数，那么类中的默认构造函数就没有了。

1. 多个构造函数是以重载的形式存在的。

/**    我们一直在使用构造方法，但是，我们确没有定义构造方法，用的是哪里来的呢?    构造方法的注意事项:        A:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。        B:如果我们给出了构造方法，系统将不再提供默认的无参构造方法。            注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法    给成员变量赋值有两种方式：        A:setXxx()        B:构造方法*/class Student {    private String name;    private int age;    public Student() {        //System.out.println("我给了，你还给不");        System.out.println("这是无参构造方法");    }    //构造方法的重载格式    public Student(String name) {        System.out.println("这是带一个String类型的构造方法");        this.name = name;    }    public Student(int age) {        System.out.println("这是带一个int类型的构造方法");        this.age = age;    }    public Student(String name,int age) {        System.out.println("这是一个带多个参数的构造方法");        this.name = name;        this.age = age;    }    public void show() {        System.out.println(name+"---"+age);    }}class ConstructDemo2 {    public static void main(String[] args) {        //创建对象        Student s = new Student();        s.show();        System.out.println("-------------");        //创建对象2        Student s2 = new Student("林青霞");        s2.show();        System.out.println("-------------");        //创建对象3        Student s3 = new Student(27);        s3.show();        System.out.println("-------------");        //创建对象4        Student s4 = new Student("林青霞",27);        s4.show();    }}

构造方法和成员变量初始化顺序

执行父类静态代码 执行子类静态代码

类的成员方法

成员方法其实就是我们前面讲过的方法

方法具体划分：

• 根据返回值：有明确返回值方法；返回void类型的方法

• 根据形式参数：无参方法；带参方法

一个基本类的标准代码写法

/**    一个标准代码的最终版。    学生类：        成员变量：            name，age        构造方法：            无参，带两个参        成员方法：            getXxx()/setXxx()            show()：输出该类的所有成员变量值    给成员变量赋值：        A:setXxx()方法        B:构造方法    输出成员变量值的方式：        A:通过getXxx()分别获取然后拼接        B:通过调用show()方法搞定*/class Student {    //姓名    private String name;    //年龄    private int age;    //构造方法    public Student() {    }    public Student(String name,int age) {        this.name = name;        this.age = age;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }    //输出所有的成员变量值    public void show() {        System.out.println(name+"---"+age);    }}//测试类class StudentTest {    public static void main(String[] args) {        //方式1给成员变量赋值        //无参构造+setXxx()        Student s1 = new Student();        s1.setName("林青霞");        s1.setAge(27);        //输出值        System.out.println(s1.getName()+"---"+s1.getAge());        s1.show();        System.out.println("----------------------------");        //方式2给成员变量赋值        Student s2 = new Student("刘意",30);        System.out.println(s2.getName()+"---"+s2.getAge());        s2.show();    }}

运行结果：

2.11 类的初始化过程

Student s = new Student();在内存中做了哪些事情?

• 加载Student.class文件进内存

• 在栈内存为s开辟空间

• 在堆内存为学生对象开辟空间

• 对学生对象的成员变量进行默认初始化

• 对学生对象的成员变量进行显示初始化

• 通过构造方法对学生对象的成员变量赋值

• 学生对象初始化完毕，把对象地址赋值给s变量

static关键字

static关键字可以修饰成员变量和成员方法

static关键字特点

• 随着类的加载而加载

• 优先于对象存在

• 被类的所有对象共享

• 这也是我们判断是否使用静态关键字的条件

• 可以通过类名调用

static关键字注意事项

• 在静态方法中是没有this关键字的

• 静态方法只能访问静态的成员变量和静态的成员方法

静态的内存图

静态变量和成员变量的区别

main方法是静态的

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

• public 被jvm调用，访问权限足够大。

• static 被jvm调用，不用创建对象，直接类名访问

• void被jvm调用，不需要给jvm返回值

• main 一个通用的名称，虽然不是关键字，但是被jvm识别

• String[] args 以前用于接收键盘录入的

• 静态什么时候用？

静态变量

当分析对象中所具备的成员变量的值都是相同时，这时这个成员就可以被静态修饰。

只要数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，是非静态的。

如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，定义成静态的。

静态函数

函数是否用静态修饰，就参考一点，就是该函数功能是否需要访问到对象中的特有数据。

简单点说，从源代码看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静态的。

如果不需要，就可以将该功能定义成静态的。当然，也可以定义成非静态，但是非静态需要被对象调用。

如果没有访问特有数据的方法，该对象的创建是没有意义。

/*    main方法的格式讲解：        public static void main(String[] args) {...}        public:公共的，访问权限是最大的。由于main方法是被jvm调用，所以权限要够大。        static:静态的，不需要创建对象，通过类名就可以。方便jvm的调用。        void:因为我们曾经说过，方法的返回值是返回给调用者，而main方法是被jvm调用。你返回内容给jvm没有意义。        main:是一个常见的方法入口。我见过的语言都是以main作为入口。        String[] args:这是一个字符串数组。值去哪里了?            这个东西到底有什么用啊?怎么给值啊?                这个东西早期是为了接收键盘录入的数据的。                格式是：                    java MainDemo hello world java*/class MainDemo {    public static void main(String[] args) {        //System.out.println(args); //[Ljava.lang.String;@175078b        //System.out.println(args.length); //0        //System.out.println(args[0]); //ArrayIndexOutOfBoundsException        //接收数据后        System.out.println(args);        System.out.println(args.length);        //System.out.println(args[0]);        for(int x=0; x

运行结果：

修饰符

关键字

转载地址：https://cpython.blog.csdn.net/article/details/111351383 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！