Java语言入门||02_面向对象与常用类||day06_类与对象，封装，构造方法

第一章面向对象思想

1.1 面向对象思想的概述

++面向过程++：当需要实现一个功能的时候，每一个具体的步骤都要亲力亲为，详细处理每一个细节

++面向对象++：当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人，来帮我做事（偷懒）

    public static void main(String[] args) {
        //用面向过程输出[1, 4, 5, 49]
        int[] arrayA = {1, 4, 5, 49};
        System.out.print("[");
        for(int i = 0; i < arrayA.length; i++){
            if(i == arrayA.length - 1) {
                System.out.println(arrayA[i] + "]");
            }else{
                System.out.print(arrayA[i] + ", ");
            }
        }
        System.out.println("===================");
        //用面向过程输出[1, 4, 5, 49]
        //找到JDK中Arrays类中toString方法
        System.out.println(Arrays.toString(arrayA));
    }

举例
特点
- 面向对象思想是一种更符合我们思考习惯的思想，它可以将++复杂的事情简单化++，并将我们++从执行者变成了指挥者++。
- 面向对象的语音中，包含了三大基本特征：封装，继承，多态

1.2 类和对象

什么是类
- 类：是一组++相关属性和行为的集合++。可以看成是++一类事物的模板++，使用事物的++属性特征和行为特征++来++描述该类事物++
- 现实中，描述一类事物
- 属性：就是该事物的状态信息
- 行为：就是该事物能够做什么
- 举例：小猫
  - 属性：名字，体重，年龄，颜色
  - 行为：走，跑，叫
什么是对象
- 对象：是一类事物的具体体现。++对象是类的一个实例++，必须具备该类事物的属性和行为
- 举例：小猫的一个实例Tim
  - 属性：名字Tim，体重65，年龄12，颜色white
  - 行为：墙根走，蹦跶跑，喵喵叫
类与对象的关系
- 类是对一类事物的描述，是++抽象的++
- 对象是一类事物的实例，是++具体的++
- ++类是对象的模板，对象是类的实体++

注：实例化一个对象——就是创建

1.3 类的定义

事物与类的对比
- 现实世界的一类事物：
  - ++属性++：事物的状态信息
  - ++行为++：事物能够做什么
- Java中用class描述事物也是如此：
  - ++成员变量++：对应事物的++属性++
  - ++成员方法++：对象事物的++行为++
类的格式
```
    public class ClassName{
        //成员变量
        //成员方法
    }
```
- ++定义类++：就是定义类的成员，包括++成员变量和成员方法++

注：++成员变量++和以前定义变量几乎是一样的。只不过位置发生的改变。在类中，方法外。

注：++成员方法++和以前定义方法机会是一样的。只不过去掉static

例：

    Student.java类中
    /*
    定义一个类来模拟“学生”事物
    属性：
        姓名
        年龄
    行为：
        吃饭
        睡觉
        学习
    
    ——对应到Java的类当中
    成员变量（属性）：
        String name;
        int age;
    成员方法（行为）：
        public void eat(){} //吃饭
        public void sleep(){}   //睡觉
        public void study(){}   //学习
    
    注意事项：
    1. 成员变量是直接定义在类当中的，在方法的外边
    2. 成员方法不要写static关键字
     */
    
    public class Student {
        //成员变量：
        String name;
        int age;
        //成员方法：
        public void eat(){  //吃饭
            System.out.println("吃饭");
        }
    
        public void sleep(){    //睡觉
            System.out.println("睡觉");
        }
    
        public void study(){    //学习
            System.out.println("学习");
        }
    }

1.4 对象的使用

通常情况下，一个类并不能直接使用，需要根据类创建一个对象，才能使用。

导包:也就是指出需要使用的类，在什么位置
- ++import 包名.类名;++
- ++对于和当前类属于同一个包的情况，可以省略导包语句++
创建
- 类名称对象名 = new 类名称();

使用

成员变量：对象名.成员变量名
成员方法：对象名.成员方法名(参数)
（也就是，想用谁，就用对象名点谁）

    Demo01Student.java类中(1.3对应)
    public static void main(String[] args) {
        //1.导包（同包不写）
        //2.创建
        Student stu = new Student();
        //3.使用
        System.out.println(stu.age);    //0
        System.out.println(stu.name);   //null
        System.out.println("=================");
        //改变对象当中成员变量数值内容
        stu.name = "黑客";
        stu.age = 18;
        System.out.println(stu.age);
        System.out.println(stu.name);
        System.out.println("=================");
        //无参
        stu.eat();
        stu.sleep();
        stu.study();
    }

注：如果成员变量没有进行赋值，那么将会有一个默认值，规则和数组一样

1.5 手机类练习

定义一个类（成员变量，成员方法）

创建一个对象（看，改，调用成员方法）

    //定义一个类（成员变量，成员方法）Phone.java
    /*
    定义一个类，模拟手机事物：
        属性：品牌，价格，颜色
        行为：打电话，发短信
    
    对应到类当中：
        成员变量：
            String brand;
            double price;
            String color;
        成员方法：
            public void call(String who){}
            public void sendMessage(){}
     */
    
    public class Phone {
        String brand;
        double price;
        String color;
    
        public void call(String who){
            System.out.println("给" + who + "打电话");
        }
    
        public void sendMessage(){
            System.out.println("群发短信");
        }
    }
    
    //创建一个对象（看，改，调用成员方法）Demo01PhoneOne.java
    public static void main(String[] args) {
        Phone one = new Phone();
        one.brand = "三星";
        one.color = "黑色";
        one.price = 4223.0;
        System.out.println(one.brand);
        System.out.println(one.price);
        System.out.println(one.color);
        System.out.println("========");
        one.call("乔布斯");
        one.sendMessage();
    }

1.6 一个对象的内存图（引用的1.5）

注：黑×代表++出栈，弹栈++：call方法完了后会从栈内存中消失
注：成员方法传递的是地址值

1.7 两个对象使用同一个方法的内存图

*注：shift + f6——>统一重命名

1.8 两个引用指向同一个对象的内存图

Phone two = one;
- 将one当中保存的++对象地址值++赋给two

注：对象的名称也叫做对象的引用名
注：两个对象引用指向了同一个对象空间

1.9 使用对象类型作为方法的参数

++带有static的++就是普通的方法，不需要对象，直接就能调用

注：当一个++对象作为参数++，++传递到方法当中时++，实际上传递进去的是++对象的地址值++

    //Demo04PhoneParam.java中
    public static void main(String[] args) {
        Phone one = new Phone();
        one.price = 3524.0;
        one.color = "绿色";
        one.brand = "苹果";

        method(one);    //传递进去的参数其实就是地址值
    }

    public static void method(Phone param){
        System.out.println(param.color);
        System.out.println(param.price);
        System.out.println(param.brand);
    }

1.10 使用对象类型作为方法的返回值

注：当使用一个++对象类型++作为++方法的返回值++时，返回值其实就是对象的地址值

    public static void main(String[] args) {
        Phone two = getPhone();
        System.out.println(two.brand);
        System.out.println(two.color);
        System.out.println(two.price);
    }

    public static Phone getPhone(){
        Phone one = new Phone();
        one.price = 3524.0;
        one.color = "绿色";
        one.brand = "苹果";
        return one; //谁调用了我，我就把one的地址交给谁
    }

1.11 成员变量和局部变量的区别

++定义的位置不一样++【重点】
- 局部变量：在方法的内部
- 成员变量：在方法的外部，直接写在类当中
++作用范围不一样++【重点】
- 局部变量：只有方法当中才可以使用，出了方法就不能再用
- 成员变量：整个类全都可以通用
++默认值不一样++【重点】
- 局部变量：没有默认值，如果想要使用，必须手动进行赋值
- 成员变量：如果没有赋值，++会有默认值++，规则和数组一样
内存的位置不一样
- 局部变量：位于栈内存
- 成员变量：位于堆内存
生命周期不一样
- 局部变量：随着方法进栈而诞生，随着方法出栈而消失
- 成员变量：随着对象创建而诞生，随着垃圾回收而消失

注：++方法的参数就是局部变量++
- 为什么是局部变量可以不赋值？
- 因为：++参数在方法的调用的时候，必然会被赋值的++

1.12 面向对象三大特征之封装性

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

封装性在Java当中的体现：
1. ++方法++就是一种封装
2. 关键字++private++也是一种封装

封装就是将一些细节信息隐藏起来，对于外界不可见。

    public static void main(String[] args) {
        int[] arrayA = {3, 5, 34, 2};
        int num = getMax(arrayA);
        System.out.println("最大值：" + num);
    }

    public static int getMax(int[] arrayA){
        int max = arrayA[0];
        for(int i = 1; i < arrayA.length; i++){
            if(arrayA[i] > max){
                max = arrayA[i];
            }
        }
        return max;
    }

1.13 private关键字的作用及使用

前面定义Person年龄的时候，无法阻止不合理的数组被设置进来。
- 用private关键字将需要保护的成员变量进行修饰
一旦使用了private进行修饰，
- 那么本类当中仍然可以随意访问。
- 但是！超出本类范围之外就不能直接访问了

间接访问private成员变量，就是定义一对Getter/Setter方法

必须叫getXxx和setXxx命名规则
++Getter来说：不能有参数，返回值类型和成员变量对应++
++Setter来说：不能有返回值，参数类型和成员变量对应++

    //定义的一个类Person.java
    public class Person {
        String name;
        private int age;
    
        public void show(){
            System.out.println("名字：" + name + "年龄：" + age);
        }
    
        //这个成员方法，专门用于向age设置数据(set就是往里放)
        public void setAge(int age){
            if(age < 100 && age >= 9){
                this.age = age;
            }else{
                System.out.println("数据不合理!");
            }
        }
    
        //这个成员方法，专门用于获取age数据（get往外拿）
        public int getAge(){
            return age;
        }
    }
    //创建一个对象Demo03Person.java
    public static void main(String[] args) {
        Person personA = new Person();
        personA.name = "赵丽颖";
        //personA.age = -34;
        personA.setAge(-20);
        personA.setAge(20);
        personA.show();
    }

1.13 利用private关键字创建学生类练习

生成Getter和Setter快捷键——>alt + Ins

注：++对于基本类型当中的boolean值++，Getter方法一定要写成isXxx的形式，而Setter规则不变。

    //定义的一个类：Student.java
    public class Student {
        private String name;
        private int age;
        private boolean male;   //判断是不是爷们
    
        public void setName(String name) {
            this.name = name;
        }
        public String getName(){
            return name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public boolean isMale() {
            return male;
        }
    
        public void setMale(boolean male) {
            this.male = male;
        }
    }
    //创建一个对象：Demo04Student.java
    public static void main(String[] args) {
        Student stu = new Student();
        stu.setAge(23);
        stu.setName("王坤");
        stu.setMale(true);

        System.out.println("姓名：" + stu.getName());
        System.out.println("年龄：" + stu.getAge());
        System.out.println("是不是爷们：" + stu.isMale());
    }

1.14 this关键字的作用

当方法的局部变量和类的成员变量++重名的时候++，根据“++就近原则++”，++优先使用局部变量++
如果需要访问本类当中的成员变量，需要使用格式：
- this.成员变量名;

this用来解决：重名，分不开的情况

    //定义的类：Person.java
    public class Person {
        String name;    //自己
        //参数name是别人的名字
        //成员变量name是自己的名字
        public void sayHello(String name){
            System.out.println(name + "你好，我是" + this.name);
        }
        //============================
        /*//参数name是别人的名字
        //成员变量name是自己的名字
        public void sayHello(String name){
            System.out.println(name + "你好，我是" + name);  //结果：王思聪你好，我是王思聪
        }*/
        //============================
        /*//参数who是别人的名字
        //成员变量name是自己的名字
        public void sayHello(String who){
            System.out.println(who + "你好，我是" + name);
        }*/
    }
    //创建一个对象：Demo01Person.java
    public static void main(String[] args) {
        Person person = new Person();
        person.name = "王健林";
        person.sayHello("王思聪");
    }

注：通过谁调用的方法，谁就是this
- 这里就是：this.name == Person.name

1.15 构造方法

构造方法是专门用来创建对象的方法，当我们++通过关键字new来创建对象时++，++其实就是在调用构造方法++
- 注：++可以用构造方法直接对private成员变量赋值,需要用get从类中拿出去(但是按照标准还是要写Getter和Setter方法)++

格式：

    public 类名称(参数类型 参数名称){
        方法体
    }

注：可以有参数也可以没有，多个参数用’,'号隔开

注意事项：

构造方法的名称必须和类名称一样，就连大小写也要一样
构造方法不要写返回值类型，练void都不写
++构造方法不能return一个具体的返回值++
如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数、方法体什么事情都不做。（public Student(){}）
一旦编写了至少一个构造方法，那么编译器将不再赠送(++如果需要默认的需要自己写++)
构造方法也可以进行重载的
- 重载：方法名称相同，参数列表不同

    定义一个类：Student.java
    public class Student {
        //成员变量
        private String name;
        private int age;
    
        //无参构造方法
        public Student(){
            System.out.println("无参构造方法执行啦");
        }
    
        //全参构造方法
        public Student(String name, int age){
            System.out.println("全参构造方法执行啦");
            this.age = age;
            this.name = name;
        }
    
        //Getter Setter
        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;
        }
    }
    //创建一个对象：Demo02Student.java
    public static void main(String[] args) {
        Student student = new Student();    //无参构造
        System.out.println("=====================");
        Student student1 = new Student("赵丽丽", 20);  //全参构造
        System.out.println("姓名：" + student1.getName() + "年龄：" + student1.getAge());
        //如果需要改变对象当中的成员变量数据内容，仍然需要使用SetXxx方法
        student1.setAge(22);
        System.out.println("姓名：" + student1.getName() + "年龄：" + student1.getAge());
    }

1.16 定义一个标准的类(练习)

一个标准的类通常拥有下面四个组成部分
1. 所有的成员变量都要使用private关键字修饰
2. 为每一个成员变量编写一对Getter/Setter方法
3. 编写一个无参构造方法
4. 编写一个全参构造方法
这样标准的类也叫做:Java Bean
创建无参构造方法的快捷键：alt + Ins->Constructor->Select None
创建全参构造方法的快捷键：alt + Ins->Constructor->全选

创建Getter/Setter的快捷键：alt + Ins->Getter and Setter

    //定义的一个学生类：Student.java
    public 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;
        }
    }
    //创建了一个学生对象：Demo01Student.java
    public static void main(String[] args) {
        Student stu = new Student();
        stu.setName("迪丽热巴");
        stu.setAge(20);
        System.out.println("姓名" + stu.getName() + "年龄" + stu.getAge());
        Student stu2 = new Student("古力娜扎", 21);
        System.out.println("姓名" + stu2.getName() + "年龄" + stu2.getAge());
        stu2.setAge(22);
        System.out.println("姓名" + stu2.getName() + "年龄" + stu2.getAge());
    }

狂野小白兔

发布了42 篇原创文章 · 获赞 6 · 访问量 1144

私信关注