面向对象（二）-搞定她-搞定程序

客官°小女子只卖身不卖艺 2022-12-28 15:27 138阅读 0赞

### [面向对象（一）-搞定她-搞定程序][-_-] ###

### 封装(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());
        }
    }

运行结果：

![format_png][]

private关键字

### 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());
        }
    }

运行结果：

![format_png 1][]

this关键字

this关键字的内存图解：

![format_png 2][]

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();
        }
    }

运行结果：

![format_png 3][]

类的成员方法

## 2.11 类的初始化过程 ##

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

*  加载Student.class文件进内存
 *  在栈内存为s开辟空间
 *  在堆内存为学生对象开辟空间
 *  对学生对象的成员变量进行默认初始化
 *  对学生对象的成员变量进行显示初始化
 *  通过构造方法对学生对象的成员变量赋值
 *  学生对象初始化完毕，把对象地址赋值给s变量

![format_png 4][]

类的初始化过程

### static关键字 ###

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

### static关键字特点 ###

*  随着类的加载而加载
 *  优先于对象存在
 *  被类的所有对象共享
 *  这也是我们判断是否使用静态关键字的条件
 *  可以通过类名调用

### static关键字注意事项 ###

*  在静态方法中是没有this关键字的
 *  静态方法只能访问静态的成员变量和静态的成员方法

静态的内存图

![format_png 5][]

静态的内存图

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

![format_png 6][]

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

### 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<args.length; x++) {
                System.out.println(args[x]);
            }
        }
    }

运行结果：

![format_png 7][]

静态函数

### 修饰符 ###

![format_png 8][]

java修饰符

### 关键字 ###

![format_png 9][]

java关键字

[-_-]: http://mp.weixin.qq.com/s?__biz=MzI3MjM5MjE5OA%3D%3D&chksm=eb3211b6dc4598a07feb5d145e08edd6c4538a9e3c57bedd48d06bb0d5e89a99383450c4f5b2&idx=3&mid=2247489759&scene=21&sn=b9d2796fb2936536f37ac061fd1225f5#wechat_redirect
[format_png]: /images/20221120/e470489fb2874316a73c03f0bf648a45.png
[format_png 1]: /images/20221120/03f572e2ece541e2948c8ed45aeb4920.png
[format_png 2]: /images/20221120/e82d900749614f3bb8569d06350c878b.png
[format_png 3]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy85eTFUZUhZejFBeXN1V016NThlRVZhS0VsZTFydU5vVTNDUjZWbUhMc1NJN0ZHV2pMWEZwTGlhZVFqbUdxTERpYWZPRDZoSThzWEs2ckFCOE1zejN0VXpBLzY0MA?x-oss-process=image/format,png
[format_png 4]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy85eTFUZUhZejFBeXN1V016NThlRVZhS0VsZTFydU5vVVVVYVZVVEJidWdKS2VpYzBLcUF3aWJqYnN0YlpleVZTb0xFNkZvMGV2ZU5hZ3dLSndmQzdVZlZ3LzY0MA?x-oss-process=image/format,png
[format_png 5]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy85eTFUZUhZejFBeXN1V016NThlRVZhS0VsZTFydU5vVTBqOEF4MDMzWGNvOVJycDg3T3JjMXlzMkpKaGxvUWRHSlZ6NFRZamliY1BHTWF4YnZjY3ZiZmcvNjQw?x-oss-process=image/format,png
[format_png 6]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy85eTFUZUhZejFBeXN1V016NThlRVZhS0VsZTFydU5vVWRnenpQMW9jdXFDOWFVeWFYT0RQbHN0UDBnSndMb2JTR29JMHljVnBMamliWXZlQTRUd1dxaWJRLzY0MA?x-oss-process=image/format,png
[format_png 7]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy85eTFUZUhZejFBeXN1V016NThlRVZhS0VsZTFydU5vVTZMZWljUWxVTGZzaWI2d0wyR1hEVnVpYjNla2NPQ1lHNVJaVkZNNUtSYXN5bWhKbUo1ZGV2TnF2Zy82NDA?x-oss-process=image/format,png
[format_png 8]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy85eTFUZUhZejFBeXN1V016NThlRVZhS0VsZTFydU5vVTkyZEd0cm9SSmRpY211cExyVE93N1dncGNkaWJYaWM4d2lhT1NPQ3lSaWI0ZnlGa0tGZEo4NXJ1RWlhZy82NDA?x-oss-process=image/format,png
[format_png 9]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy85eTFUZUhZejFBeXN1V016NThlRVZhS0VsZTFydU5vVXliNnRzVWxpYjg0eEFrYjROQ21CZHFQTUNiNXBpY1JXaWJhUVRuZFRzV0N2RXZGY0M4Z2FPdFJndy82NDA?x-oss-process=image/format,png