JavaSe-Day6-面向对象;类和对象;

面向对象

面向过程

·当需要实现一个功能的时候，每一个具体步骤都需要亲力亲为，详细处理每个细节。(强调自己做)

面向对象

·当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人，来帮我做事。(强调别人做，这个人就是“对象”)

package Demo;
import java.util.Arrays;
/**
 * @author Edwin D
 * @date 2020.4.1 下午 11:16
 */
/*
* 输出[7,77,777,7777,77777]
* */
public class DemoArray01{
    public static void main(String[] args) {
        int[] array = {7,77,777,7777,77777};
//      使用面向过程的方法。每一步都亲力亲为。
        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] + ", ");
        }

//      使用面向对象的方法，
//      找一个JDK写好的Arrays类的方法toString，直接把数组变成字符串。
        System.out.println("++++++++++++++++++++++++++");
        System.out.println(Arrays.toString(array));
    }
}

面向对象的三大特征

·封装

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

2.方法就是一种封装。

3.关键字private也是一种封装。

package DemoEncapsulation;
/**
 * @author Edwin D
 * @date 2020.4.2 下午 6:40
 */
public class DemoMax {

    public static void main(String[] args) {
        int[] array = {7,77,777,7777,77777};
        int max = getMax(array);
        System.out.println("The Max is " + max);
    }
//封装成getMax，原本应该将15-20卸载main()里的
    public static int getMax(int[] A){
        int max = A[0];
        for (int i = 0; i < A.length; i++) {
            if(A[i]>max)
                max = A[i];
        }
        return max;
    }
}

Private封装

·访问某个Class的Private成员变量的时候，可以使用Getter和Setter方法间接访问。Eg：

package DemoEncapsulation;
/**
 * @author Edwin D
 * @date 2020.4.2 下午 6:57
 */
/*
* 间接访问Private成员变量，就是定义一对Getter和Setter方法。
* */
public class Person {
    String name;
    private int age;

    //该成员方法往age里放变量数值。
    public void setAge(int num){
        if(num<120 && num>=0)
            age = num;
        else
            System.out.println("Error age Number!");
    }
    //该成员方法专门获取age变量数值
    public int getAge(){
        return age;
    }
    public void show(){
        System.out.println("My name is " + name + " and i am " + age +" years' old.");
    }
}

命名规则：

·必须叫setXxx或者getXxx

·对于Getter，不能有参数，返回值类型须和成员变量对应。

·对于Setter，不能有返回值，参数类型和成员变量对应。

package DemoEncapsulation;
/**
 * @author Edwin D
 * @date 2020.4.2 下午 6:57
 */
public class DemoPerson {
    public static void main(String[] args) {
        Person p = new Person();
        p.show();
        System.out.println("++++++++++++++++++++");
        p.setAge(-17);
        p.name = "成果果";
        p.show();
    }
}

布尔值的Getter方法

·布尔值的Getter方法是与众不同的，用的是isXxx().

package DemoEncapsulation;
/**
 * @author Edwin D
 * @date 2020.4.2 下午 8:40
 */
public class DemoActor {
    private boolean male;
    public void setMale(boolean T) {
        male = T;
    }
    public boolean isMale() {
        return male;
    }
}

package DemoEncapsulation;
/**
 * @author Edwin D
 * @date 2020.4.2 下午 8:46
 */
public class DemoActorRun {
    public static void main(String[] args) {
        DemoActor A = new DemoActor();
        A.setMale(true);
        System.out.println(A.isMale());
    }
}

相同变量名的区分

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

this.成员变量名

this：指的是通过谁调用的this，this就代指谁。

package DemoEncapsulation;
/**
 * @author Edwin D
 * @date 2020.4.2 下午 9:00
 */
public class DemoThis {
    String name;
    //我是name，对方是who
    public void sayHello(String name){
        System.out.println("Hello " + name + ", I am " + this.name);
    }
}

package DemoEncapsulation;
/**
 * @author Edwin D
 * @date 2020.4.2 下午 9:03
 */
public class DemoThat {
    public static void main(String[] args) {
        DemoThis T = new DemoThis();
        T.name = "Edwin";
        T.sayHello("Tony");
    }
}

·继承

·多态

类和对象

类：

一组相关属性和行为的集合。可以看成一类事物的模板，使用事物的属性特征和行为特征来描述该类事物。

·属性：该事物的状态信息。

·行为：该事物能够做什么。

package DemoPhone;
/**
 * @author Edwin D
 * @date 2020.4.2 下午 12:11
 */
/*
* 定义手机的“类”，来模仿手机。
*   属性：品牌，价格，颜色。
*   行为：打电话，发短信。
*
* 对应：
* 成员变量：品牌，价格，颜色。
* String brand;
* double price;
* String color;
* 成员方法：打电话，发短信。
*   public void call(String who){} //给who打电话
*   public void sendmassage(){}    //群发短信
* */
public class DemoPhone {
//    成员变量
    String brand;
    double price;
    String color;
//    成员方法
    public void call(String who){
        System.out.println("给" + who + "一个Call");
    }

    public void sendmassage() {
        System.out.println("过年群发！");
    }
}

标准的类

1.所有成员变量都要使用private关键字修饰；

2.为每一个成员变量编写一对儿Getter/Setter方法；

3.编写一个无参数的构造方法；

4.编写一个全参数的构造方法；

package DemoEncapsulation;
/**
 * @author Edwin D
 * @date 2020.4.2 下午 9:46
 */
public class DemoAll {
    private String name;
    private int age;
    public DemoAll() {
    }
    public DemoAll(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;
    }
}

package DemoEncapsulation;
/**
 * @author Edwin D
 * @date 2020.4.2 下午 9:51
 */
public class DemoAllRun {
    public static void main(String[] args) {
        DemoAll A = new DemoAll();
        A.setName("成果果");
        A.setAge(25);
        System.out.println("I am " + A.getName() + " and I am " + A.getAge() + " years'd old!");
        System.out.println("++++++++++++++++++++++");
        DemoAll B = new DemoAll();
        B.setName("Ai成果果");
        B.setAge(27);
        System.out.println("I am " + B.getName() + " and I am " + B.getAge() + " years'd old!");
        System.out.println("++++++++++++++++++++++");
        B.setAge(28);
        System.out.println("I am " + B.getName() + " and I am " + B.getAge() + " years'd old!");
    }
}

对象：

一类事物的具体表现。是针对类的一个实例，具备该事物的属性和行为。

另举例：小猫。
属性：名字、体重、年龄、颜色。 行为：走、跑、叫。

类与对象的关系

·类是对一类事物的描述，是抽象的。
·对象是一类事物的实例，是具体的。
·类是对象的模板，对象是类的实体 。

类的使用

1.导包：

指出需要使用的类在什么位置

• import 包名.类名
• Eg：import Demo.DemoStudent;
• 对于和当前类属于同一个Package中的情况，可以省略导包语句而不写。
• 如现在的DemoStudent和DemosStudentRun在同一个叫Demo的Package中，就可以省略

2.创建

• 格式： 类名称 对象名 = new 类名称();
• Eg: DemosStudent stu = new DemosStudentRun();

3.使用

分两种情况。

• （1）使用成员变量：对象名.成员变量名
• （2）使用成员方法：对象名.成员方法名（参数）
• （即想用谁，就对象点谁）

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

package Demo;
/**
 * @author Edwin D
 * @date 2020.4.2 上午 12:02
 */
public class DemosStudentRun {
    public static void main(String[] args) {
//        1.导包
//        所需要使用的DemosStudent类，和DemosStudentRun处在同一个package下，无需import。

//        2.创建格式：
//        类名 对象名 = new 类名();
//        根据Student类，创建了一个名为Stu的对象
        DemoStudent Stu = new DemoStudent();

//        3.使用其中的成员变量，格式：
//        对象名.成员变量名
        System.out.println(Stu.name);
        System.out.println(Stu.age);

        System.out.println("+++++++++++++++++++++++");
//        改变成员变量的数值内容，
        Stu.name = "成果果";
        Stu.age = 25;
        System.out.println(Stu.name);
        System.out.println(Stu.age);

//        3.使用对象的成员方法，格式：
//        对象名.成员方法名()
        Stu.study();
        Stu.eat();
        Stu.old();
    }
}

一个对象调用的过程

两个对象调用过程

1.两个不同地址的对象

2.两个相同地址的对象

package Demo;
/**
 * @author Edwin D
 * @date 2020.4.2 下午 12:24
 */
public class DemoPhoneCall {
    public static void main(String[] args) {
//        根据DemoPhone创建一个对象，叫做pho，
        DemoPhone pho = new DemoPhone();
        System.out.println(pho.brand);
        System.out.println(pho.price);
        System.out.println(pho.color);
        System.out.println("+++++++++++++++++++");

        pho.brand = "Mi-8";
        pho.price = 3299;
        pho.color = "Black";
        System.out.println(pho.brand);
        System.out.println(pho.price);
        System.out.println(pho.color);
        System.out.println("+++++++++++++++++++");

        pho.call("雷军");
        pho.sendmassage();
        System.out.println();

        
        DemoPhone pho2 = new DemoPhone();
        System.out.println(pho2.brand);
        System.out.println(pho2.price);
        System.out.println(pho2.color);
        System.out.println("+++++++++++++++++++");

        pho2.brand = "Mi-9";
        pho2.price = 3999;
        pho2.color = "Blue";
        System.out.println(pho2.brand);
        System.out.println(pho2.price);
        System.out.println(pho2.color);
        System.out.println("+++++++++++++++++++");

        pho2.call("雷军");
        pho2.sendmassage();
        System.out.println();


        DemoPhone pho3 = pho;
        System.out.println(pho3.brand);
        System.out.println(pho3.price);
        System.out.println(pho3.color);
        System.out.println("+++++++++++++++++++");

        pho3.brand = "Mi-10";
        pho3.price = 4299;
        pho3.color = "White";
        System.out.println(pho3.brand);
        System.out.println(pho3.price);
        System.out.println(pho3.color);
        System.out.println("+++++++++++++++++++");

        pho3.call("雷军");
        pho3.sendmassage();
        System.out.println();
    }
}

3.地址的传递

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

package DemoPhone;
/**
 * @author Edwin D
 * @date 2020.4.2 下午 4:41
 */
public class DemoPhoneParam {

    public static void main(String[] args) {
        DemoPhone one = new DemoPhone();
        one.brand = "Mi-Max1";
        one.color = "Colorful";
        one.price = 5999;
        
        method(one);
    }

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

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

package DemoPhone;
/**
 * @author Edwin D
 * @date 2020.4.2 下午 4:53 
 */
public class DemoPhoneReturn {

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

    private static DemoPhone getPhone() {
        DemoPhone A = new DemoPhone();
        A.brand =  "Mi-Max2";
        A.color = "Colorful";
        A.price = 5999;
        return A;
    }
}

局部变量和成员变量

	局部变量	成员变量
定义位置	方法内部	方法外部，在类当中
作用范围	方法中	整个类
默认值	无默认值	有默认值
内存位置	位于栈内	位于堆内
生命周期	随方法进栈而生，随方法出栈而消失	随对象创建而生，随对象被回收而消失

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-V3xCkttn-1585835992864)(C:\Users\Yuan\AppData\Roaming\Typora\typora-user-images\image-20200402123333606.png)]

构造方法

·指专门用来创建对象的方法，当我们通过关键字new来创建对象时，就是在调用构造方法

格式：

public 类名称（参数类型 参数名，参数名……){

​ 方法体

}

注意:

1.构造方法的名称必须和Class完全一样，包括大小写。
2.构造方法不要写返回值类型，甚至连Void都不需要。
3.构造方法不能return一个具体的返回值。
4.如果没有编写任何构造方法，那么编译器将会自动赠送一个构造方法，不含任何构造体和参数。
即赠送一个：public Student(){}
5.一旦编写了一个构造方法，那么编译器将不再赠送。
6.构造方法是可以重载的。（重载：方法名称相同，参数列表不同）

package DemoConstruction;
/**
 * @author Edwin D
 * @date 2020.4.2 下午 9:20
 */
public class Student {
    private String name;
    private int age;
//无参数构造
    public Student(){
        System.out.println("无参数构造方法成功！");
    }
//全参数构造
    public Student(String name,int age){
        System.out.println("全参数构造方法成功！");
        this.name = name;
        this.age = age;
    }
//Getter  Setter
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }
}

package DemoConstruction;
/**
 * @author Edwin D
 * @date 2020.4.2 下午 9:22
 */
public class DemoStudent {
    public static void main(String[] args) {
//        new Student();就是在调用构造方法。
        Student stu1 = new Student();
        System.out.println("++++++++++++++++");
        Student stu2 = new Student("Wujing",37);
        System.out.println("I am " + stu2.getName() + " and I am " + stu2.getAge() + " years' old!");
        System.out.println("++++++++++++++++");
        stu2.setAge(47);
        System.out.println("I am " + stu2.getName() + " and I am " + stu2.getAge() + " years' old!");
    }
}

参考文献：

《黑马Java基础班视频》

《黑马Java基础教材笔记》

2020.04.02