JavaStudy06 类与对象、封装、构造方法

20200313 睡前回顾0506
20200315 今天和方同学、胡同学交流后，听取他们宝贵的建议，你不要再偷懒了噢！火力全开吧！明确了目标和学习计划，加油日日更新！
态度！坚持！
20200320完成Day06 有的放矢 关注进步

今日内容与教学目标

Bug

1、词不达意 type型号=华为=品牌

Question

1.how to ： idea自动生成；

回顾

https://mubu.com/doc/x83KYTNUy0

一、面对对象

1.1定义

面对对象相当于让会这件事的人来做不关心过程；面对过程是自己一步步操作。

• 生活实例：自己洗衣和洗衣机洗衣。
• 代码示例：打印[2,4,5,6,7]
  使用面向对象，找到一个JDK给我们提供好的Arrays类，其中有一个toString方法，直接就能把数组变成想要的格式的字符串

package demo01;

import java.util.Arrays;

//打印[2,4,5,6,7]
public class Demo01PrintArray {

    public static void main(String[] args) {
        //面向过程 每一个细节都要亲力亲为
        //分析，
    /*  1.定义一个数组来拿数字
        2.[
        3.循环打印，非最后一个 数字，最后一个数字]
        */
        int[] array = {2,4,5,6,7};
        System.out.print("[");

        for (int i = 0; i < array.length; i++) {
            if(i==array.length-1){
                System.out.println(array[i]+"]");
            }else{
                System.out.print(array[i]+", ");
            }
        }
        System.out.println("=======");
        //面向对象
        /*分析：
        导可以打印这种格式的包*/
        /*使用面向对象，找到一个JDK给我们提供好的Arrays类，其中有一个toString方法，直接就能把数组变成想要的格式的字符串*/
        System.out.println(Arrays.toString(array));
    }
}

1.2面向对象特点

三大特征：封装、继承、多态

1.3类和对象的定义

（1）类：模拟对象的属性和行为，抽象的。

• 属性（成员变量）：对象的状态。是什么。如猫的年龄体重颜色
• 行为（成员方法）：对象的行为。做什么。如猫走、跳

（2）对象：具体的事物。

扫描二维码关注公众号，回复： 10163201 查看本文章

（3）类和对象的关系：类是对象的模板，对象是类的实体，如同手机设计图和真实手机。
（4）

• 类的定义格式

public class ClassName {
//成员变量
//成员方法
}

注意事项：
1.成员变量写在类内方法外
2.成员方法不写static关键字
@Student类

package demo01;
/*注意事项：
 1.成员变量写在**类内方法外**
 2.成员方法**不写static**关键字
 */
//成员变量
//  String name；int age；
//成员方法
// public void eat(){}; public void sleep(){}; public void study(){};
public class Student {
    String name;
    int age;
    public void eat(){
        System.out.println("eat");
    }
    public void sleep(){
        System.out.println("sleep");
    }
    public void study(){
        System.out.println("study");
    }

}

1.4 对象的使用

对象的使用格式

根据类创建对象的格式

类名称 对象名 = new 类名称（）；

@代码示例：写一个学生类

通常情况下，一个类不能直接使用，需要根据类创建对象才能使用
1、导包：就是指出需要的类在什么位置（若和当前类同一个包则可不写导包语句）
import 包名称.类名称;
import demo01.Student;

• 2、创建对象格式
  类名 对象名 = new 类名();
  Student stu = new Student();
• 3、使用，分为两种情况，用谁点谁：
  使用成员变量：对象名.成员变量
  使用成员方法：对象名.成员方法名(参数)

package demo01;
/*通常情况下，一个类不能直接使用，需要根据类创建对象才能使用
1、导包：就是指出需要的类在什么位置（若和当前类同一个包则可不写导包语句）
import 包名称.类名称;
import demo01.Student;

2、创建对象格式
类名 对象名 =  new 类名();
Student stu = new Student();

3、使用，分为两种情况，用谁点谁：
使用成员变量：对象名.成员变量
使用成员方法：对象名.成员方法名(参数)
*/
public class Demo02Student {
    public static void main(String[] args) {
        //1、导包，同一个包省略
        //2、创建对象
        Student stu = new Student();
        //3、使用成员变量
        System.out.println(stu.name);//int 0
        System.out.println(stu.age);//String null
        System.out.println("======");

        //改变成员变量值
        stu.name = "小A";
        stu.age= 18;
        System.out.println(stu.name);
        System.out.println(stu.age);
        System.out.println("======");

        //4、使用成员方法
        stu.eat();
        stu.sleep();
        stu.study();

    }
}

成员变量的默认值

1.5 类与对象的练习

• 手机类练习

定义手机类

package demo01;
//练习创建类
//成员变量（类内方法外）：属性：颜色、尺寸、型号type
// 成员方法：行为：阅读、拍照、计时、听音乐
public class Phone {
    //成员变量（类内方法外）：属性：颜色、尺寸、型号type
    String color;
    double size;
    String type;

    // 成员方法：行为：阅读、拍照、计时、
    public void read(String who){
        System.out.println("阅读"+who);
    }
     public void photograph(){
        System.out.println("拍照");
    }
     public void time(){
        System.out.println("计时");
    }



}

定义测试类：

package demo01;
//练习调用类
public class Test03Phone {
    public static void main(String[] args) {
        //1、导包无须

        //2、创建对象
        Phone x = new Phone();

        //3、使用成员变量
        System.out.println(x.color);//null
        System.out.println(x.size);//0.0
        System.out.println(x.type);//null
        System.out.println("=======");

        //4、给成员变量赋值
        x.color = "黄色";
        x.size = 9.7;
        x.type = "HUAWEI";
        System.out.println("=======");

        //5、使用新赋值的成员变量
        System.out.println(x.color);
        System.out.println(x.size);
        System.out.println(x.type);

        //6、使用成员方法
        x.photograph();
        x.read(书籍);
        x.time();

    }


}

1.6 对象内存图

方法结束就出栈，main方法结束内存就空了，成员方法保存的是地址值

一个对象，调用一个方法内存图

在栈内存中运行的方法，遵循"先进后出，后进先出"的原则。

两个对象，调用同一方法内存图

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

使用对象类型作为方法的参数内存图

引用类型作为参数，传递的是地址值。

当对象/类/数组作为参数，传递到方法当中时，实际上传递进去的是对象的地址值，有了地址值想用谁就点谁。

使用对象类型作为方法的返回值内存图

1.7 成员变量和局部变量区别

• 3重点：定义位置、作用范围、默认值
  2了解：内存位置、生命周期

第2章 封装

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

2.1 封装概述

封装性在Java中的体现：
1、方法就是一种封装：封装就是将一些细节信息隐藏起来，对于外界不可见，只管调用即可不管方法内程序是什么。
2、关键字private也是一种封装：用private关键字将需要保护的成员变量进行修饰
一旦使用了private进行修饰，本类可以直接访问，但是超出本类不可直接访问，可通过定义Getter/Setter方法间接访问private成员变量，必须叫setXxx或者是getXxx命名规则。对于Getter来说，不能有参数，返回值类型和成员变量对应；对于Setter来说，不能有返回值，参数类型和成员变量对应。
。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性

原则

将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问

2.2 封装的步骤

1. 使用 private 关键字来修饰成员变量。
2. 对需要访问的成员变量，提供对应的一对 getXxx 方法 、 setXxx 方法。
   （注意：如果是boolean类型，Getter不变，Setter方法命名为isXxx）

2.3 封装的操作——private关键字

private的含义

1. private是一个权限修饰符，代表最小权限。
2. 可以修饰成员变量和成员方法。
3. 被private修饰后的成员变量和成员方法，只在本类中才能访问。

private的使用格式

private 数据类型 变量名 ；

练习使用private关键字定义学生类

package demo01;

public class Test06Student {
    private String name ;
    private int age;
    private boolean male;
    public void setName(String str){
        name = str;
    }
    public String getName() {
        return name;
    }
    public void setAge(int num){
        age = num;
    }
    public int getAge(){
        return age ;
    }
    public void setMale(boolean b){
        male = b;
    }
    public boolean isMale(){
        return  male;
    }
}

package demo01;

public class DemoStudent {
    public static void main(String[] args) {
        Test06Student stu = new Test06Student();
        stu.setName("张三");
        stu.setAge(3);
        stu.setMale(true);
        System.out.println("姓名："+stu.getName());
        System.out.println("年龄"+stu.getAge());
        System.out.println("是不是男的"+stu.isMale());
    }
}

2.4 封装优化1——this关键字

this的含义

this代表所在类的当前对象的引用（地址值），即对象自己的引用。方法被哪个对象调用，方法中的this就代表那个对象。即谁在调用，this就代表谁。

this使用格式

this.成员变量名；

• 当方法的局部变量和类的成员变量重名的时候，根据“就近原则”，默认使用局部变量，如果需要访问本类当中的成员变量，需要使用格式this.成员变量名。解决成员变量被隐藏的问题。方法中只有一个变量名时，默认也是使用 this 修饰，可以省略不写

2.5 封装优化2——构造方法

当一个对象被创建时候，构造方法用来初始化该对象，给对象的成员变量赋初始值。

小贴士：无论你与否自定义构造方法，所有的类都有构造方法，因为Java自动提供了一个无参数构造方法，
一旦自己定义了构造方法，Java自动提供的默认无参数构造方法就会失效。

构造方法的定义格式

修饰符 构造方法名(参数列表){
// 方法体
}

注意事项

1. 构造方法的写法上，方法名与它所在的类名相同，大小写也要一样。
2. 它没有返回值，所以不需要返回值类型，甚至不需要void。
3. 构造方法不能return一个具体的返回值
4. 如果你不提供构造方法，系统会给出无参数构造方法。
5. 如果你提供了构造方法，系统将不再提供无参数构造方法。
6. 构造方法是可以重载的，既可以定义参数，也可以不定义参数。

2.6 标准代码——JavaBean

JavaBean 是 Java语言编写类的一种标准规范。符合 JavaBean 的类，要求类必须是具体的和公共的，并且具有无参数的构造方法，提供用来操作成员变量的 set 和 get 方法。

一个标准的类通常有四个组成部分：

1. 所有成员变量用private修饰
2. 为每一个成员变量编写一对Getter、Setter方法
3. 编写一个无参数的构造方法
4. 编写一个有参数的构造方法

public class ClassName{
//成员变量
//构造方法
无参构造方法【必须】
有参构造方法【建议】
//成员方法
getXxx()
setXxx()
}

学生类

• 用封装的思想定义一个标准类

package demo03;

public class Student {
    //成员变量
    private String name;
    private int age;

    //构造方法
        //无参构造方法

    public Student() {
    }

    //有参构造方法

    public Student(String name,int age){
        this.name = name;
        this.age = age;
    }
    //成员方法
        //Setter、Getter


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

测试学生类

package demo03;

public class DemoStudent {
    public static void main(String[] args) {
        Student stu0 = new Student();
        stu0.setName("白玉");
        stu0.setAge(26);
        System.out.println("姓名"+stu0.getName()+",年龄"+stu0.getAge());
        System.out.println("======");

        Student stu1 = new Student("大麦",27);
        System.out.println("姓名"+stu1.getName()+",年龄"+stu1.getAge());
        stu1.setAge(22);
        System.out.println("姓名"+stu1.getName()+",年龄"+stu1.getAge());


    }
}