Java基础学习笔记：第四章（一）面向对象编程

知识点1：面向对象的理解

1. 面向过程 vs 面向对象

二者都是一种思想，面向对象是相对于面向过程而言的。面向过程，强调的是功能行为，以函数为最小单位，考虑怎么做。面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

2. 类与对象的理解

面向对象中的两大核心概念
* 1. 类（class）：对一类事物的描述，是抽象的、概念上的定义。
* 2. 对象（object\instance）：由类派生(new)出的一个个的实体。

3. 学习的三条主线

面向对象编程的学习三条主线：
* 1. 类及类中的成员：属性、方法、构造器；内部类、代码块
* 2. 面向对象的三个特征：封装、继承、多态、（抽象）
* 3. 其它关键字的使用：this\super\import\package\static\final\abstract\interface\....

说明：

类的内部成员：
*   属性 = 成员变量 = field
*   方法 = 成员方法 = (成员)函数 = method

知识点2：类及对象的创建过程

* 1. 设计类，就是设计类的内部成员。。
*
* 2. 设计类、创建对象、调用功能的步骤：
* 第1步：创建类（实际上，就是创建类的成员:属性、方法）
* 第2步：创建类的对象 （或 创建类的实例、类的实例化）
* 第3步：通过"对象.属性"或"对象.方法"的方式，调用对象的内部结构

• 代码说明

public class PhoneTest {  //测试类
    public static void main(String[] args) {
        //数据类型  变量名 = 变量值
        Scanner scan = new Scanner(System.in);
//        int number = scan.nextInt();

        //创建Phone类的对象
        Phone iphone = new Phone();

        //通过"对象.属性"或"对象.方法"的方式，调用对象的内部结构
        iphone.name = "苹果手机";
        iphone.price = 8999;

        System.out.println("name:" + iphone.name + ", price:" + iphone.price);

        iphone.call();
        iphone.sendMessage("有内鬼，停止交易！");
        String info = iphone.takePhoto();
        System.out.println(info);

        //##################
        Phone iphone1 = new Phone();
        iphone1.name = "华为P40 pro";
        iphone1.price = 4999;
        System.out.println("name:" + iphone1.name + ", price:" + iphone1.price);
        System.out.println("name:" + iphone.name + ", price:" + iphone.price);

        //##################
        Phone iphone2 = iphone;
        iphone2.price = 6999;

        System.out.println("name:" + iphone.name + ", price:" + iphone.price);

        //##############
        iphone.sendMessage("你好！很高兴认识你");
    }
}


class Phone{
    //1. 设计属性
    String name;//手机名称
    int price;//价格

    //2. 设计方法
    public void call(){
        System.out.println("手机可以拨打电话");
    }
    public void sendMessage(String message){
        System.out.println("发送信息：" + message);
    }

    public String takePhoto(){
        //System.out.println("拍照");
        return "拍照成功";
    }
}

内存解析：

如果创建了类的多个对象，则每个对象拥有一套类的属性。当我们修改其中一个对象的属性时，不影响其它对象
* 此属性的值。
*
*  如果将对象引用p1赋给新的变量p2，则p1和p2就共同指向了堆空间中唯一的一个对象实体。当我们通过其中一个引用
*  修改对象的属性的话，则会导致另外引用对同一个属性的值的调用。

知识点3：成员变量vs局部变量

测试类中属性的定义
*
* 1. 回顾：变量的分类
* ① 按照数据类型来分： 基本数据类型（8种）  vs  引用数据类型（类、数组、接口）
*
* ② 按照类中声明的位置： 成员变量（或属性）   vs  局部变量
*   说明：成员变量：在类中直接定义的变量
*        局部变量：在方法内、构造器内、代码块内等定义的变量
*
* 2.  成员变量（或属性）   vs  局部变量
* 相同点：
*       1. 变量声明的格式相同：数据类型 变量名 = 变量值
*       2. 凡是变量，都需要先声明，后使用
*       3. 都有其作用域。超出作用域，不可调用
*
* 不同点：
*      1. 声明位置的不同。
*          > 成员变量：在类中直接定义的变量
*          > 局部变量：在方法内、构造器内、代码块内等定义的变量
*      2. 是否可以使用权限修饰符进行修饰。
*          > 权限修饰符有：private \ 缺省 \ protected \ public
*          > 成员变量可以使用权限修饰符进行修饰 ；
*            局部变量不可以使用权限修饰符进行修饰
*          > 暂时，我们在定义成员变量时，大家都使用缺省即可。（讲封装性时再说）
*      3. 是否有默认初始化值的情况
*          > 成员变量都有默认初始化值
*                  ① 如果成员变量是整型(byte\short\int\long)，则默认值为：0
*                  ② 如果成员变量是浮点型(float \ double)，则默认值为：0.0
*                  ③ 如果成员变量是boolean型，则默认值为：false
*                  ④ 如果成员变量是char型，则默认值为：0 或 '\u0000'
*                  ⑤ 如果成员变量是引用数据类型，则默认值为：null
*
*          > 局部变量都没有默认初始化值。则意味着在调用局部变量之前，一定要显式的赋值。
*
*      4. 在内存中存储的位置不同
*          >成员变量存储在堆空间中
*          >局部变量存储在栈空间中
*
* @author shkstart
* @create 2020-06-30 16:19
*/

• 代码演示

public class PersonTest {
    public static void main(String[] args) {
        Person p1 = new Person();

        System.out.println(p1.name +"," + p1.age + "," + p1.gender);

        p1.sleep();
        p1.eat("湖南臭豆腐");

        Person p2 = new Person();
        System.out.println(p2.age);
    }
}

class Person{
    //声明成员变量(属性)
    String name;
    int age = 1;
    boolean gender;//性别

    public void sleep(){
        int hour = 6; //局部变量
        System.out.println("人每天应该至少保证" + hour + "小时的睡眠");
    }

    public void eat(String food){//food:局部变量
        System.out.println("我喜欢吃：" + food);
    }

}

知识点4：方法的声明

* 类中方法的声明测试
 * 1. 之前用过的一些方法：
 *  Scanner类的nextInt() \ next()
 *  Math类的random() \ sqrt(double d)
 *  Arrays类的equals(int[] arr1,int[] arr2) \ toString(int[] arr) \ sort(int[] arr)
 *           \ binarySearch(int[] arr,int value)
 *
 * 2. 类中方法声明的格式：
 *   权限修饰符  返回值类型  方法名(形参列表){
 *          方法体
 *   }
 *   说明：关于方法中的特殊关键字：static\final\abstract\...暂时先不考虑。
 *
 * 3. 方法声明的详细说明：
 *   3.1 权限修饰符：指名当前方法被调用权限的大小。
 *       涉及到的权限修饰符有：private 、 缺省 、 protected 、 public。 详细细节见《封装性》
 *       目前，大家在声明方法时，默认使用public即可。
 *   3.2  返回值类型 ：
 *       > 可以分为：有具体的返回值类型  vs  没有返回值类型：void
 *       > 有具体的返回值类型，可以使用任何的变量类型。比如：基本数据类型、引用数据类型
 *       > 有具体的返回值类型的方法，在调用方法结束后，一定要返回满足要求的返回值类型的变量或常量
 *     补充：return的使用：
 *         在有具体返回值类型的方法中，一定需要使用“return + 变量/常量”的方法给方法返回指定的数据。
 *         如果方法没有返回值类型，也可以使用"return;"结构，表示结束当前方法的执行。
 *
 *    3.3 方法名：属于标识符，命名时满足标识符命名的规则和规范。“见名知意”
 *    3.4 形参列表：
 *      格式：参数类型1 参数名1,参数类型2,参数名2,...
 *      方法在声明时，不要给形参列表的变量赋值。当我们调用方法时，才给形参列表赋值：实参。
 *    3.5 方法体：执行方法时，主要操作的逻辑。
 
  * 4. 如何确定定义一个方法时，要不要声明返回值类型？要不要声明形参？
 *    ① 看题目要求。
 *    ② 具体问题具体分析。

• 代码演示

public class PersonTest {
    public static void main(String[] args) {
        Person p = new Person();
        p.printNumber();
        int hour = 8;
        p.sleep(hour);

        System.out.println("##############");
        p.eat();

    }
}

class Person{
    String name;
    int age;
    Account acct;

    public void printNumber(){

        for(int i = 0;i < 100;i++){
            if(i == 40){
                return;//用于结束方法
            }
            System.out.println(i);
        }

        System.out.println("hello!");
    }

    public Account getAccount(){
        boolean flag = true;
        if(flag){
            return null;
        }

        return new Account();

    }

    public int getValue(){
        return 1;
//        return age;
    }

    public void sleep(int hour){
        System.out.println("昨天睡了" + hour + "小时");
    }

    public void eat(){
        System.out.println("人需要吃饭，补充营养");
        System.out.println("name = " + name);

        sleep(10);

//        eat();

    }

}

class Account{//账户

}

• 补充说明

 * 5. > 可以在当前类的方法中使用当前类定义的属性或其他的方法
 *    > 方法内不能定义新的方法。

• 课后练习

/**
 * 2.利用面向对象的编程方法，设计类Circle计算圆的面积。
 *
 * @author shkstart
 * @create 2020-07-01 11:37
 */
public class CircleTest {

    public static void main(String[] args) {
        Circle c1 = new Circle();

        c1.radius = 1.2;
        //对应方式一
//        double area = c1.findArea();
//        System.out.println("圆的半径为：" + c1.radius + ",面积为：" + area);

        //对应方式二：
        c1.findArea();
    }

}

class Circle{//圆
    double radius;//半径

    //求圆的面积的方法
    //方式一：
//    public double findArea(){
//        return Math.PI * radius * radius;
//    }
    //方式二：
    public void findArea(){
        System.out.println(Math.PI * radius * radius);
    }

    //错误的：
//    public double findArea(double r){
//        return Math.PI * r * r;
//    }


}

知识点5：方法的重载

• 概念的理解

 * 1. 什么是方法的重载？同一个类中，相同方法名，不同参数列表的方法之间构成重载。
 *
 *   “两同一不同”：同一个类，相同方法名；参数个数 或 参数类型不同
 *
 * 2. 方法的重载与权限修饰符、返回值类型、形参名没有关系！

• 代码演示

public class OverLoadTest {
    public static void main(String[] args) {
        OverLoadTest test = new OverLoadTest();
        test.show();

        test.show(1,2);
    }

    public void show(){
        System.out.println("hello");
    }
    public void show(int a){
        System.out.println("萨瓦迪卡");
    }

     void show(String info){
        System.out.println(info);
    }
    public int show(int i,int j){
        return i + j;
    }
    private void show(int i,String info){

    }
    public void show(String info,int i){

    }
//    public void show(String info1,int j){
//
//    }

//    public String show(String info,int i){
//          return info + i;
//    }



}

• 重点

* 3. 我们在调用类中的方法时，是如何确定调用的是某一个确定的方法呢？
 *    通过方法名确定  ---> 进一步通过形参列表确定

知识点6：可变形参的方法

/**
 *  可变形参方法的使用
 *
 *  1. JDK5.0新增的特性。
 *  2. 格式为：形参类型 ... 形参名
 *  3. 当调用可变形参的方法时，实参可以为0个，1个，2个，。。。
 *  4. 可变形参的方法与方法同名的其他方法之间构成重载（排除第5点)
 *  5. 一个类中，不能同时出现可变形参的方法 和 与其方法名相同且可变形参类型相同的数组的方法。
 *  6. 如果一个方法中声明有可变形参，则可变形参一定声明在方法参数的最后。
 *  7. 一个方法的形参中，最多声明一个可变个数的形参结构。
 *
 *
 * @author shkstart
 * @create 2020-07-01 14:59
 */
public class ArgsTest {
    public static void main(String[] args) {

//        int[] arr = new int[0];

        ArgsTest test = new ArgsTest();
//        test.show();
//        test.show("abc");
        test.show("abc","123","xyz");
//
        test.show(new String[]{"abc","def"});
    }

    public void show(){
        System.out.println("show()");
    }
    public void show(String s){
        System.out.println("show(String s)");
    }

    public void show(int i){
        System.out.println("show(int i)");
    }

    public void show(String ... info){
        System.out.println("show(String ... info)");
        for(int i = 0;i < info.length;i++){
            System.out.println(info[i]);
        }
    }

//    public void show(String[] info){
//          for(int i = 0;i < info.length;i++){
//                System.out.println(info[i]);
//          }
//    }

    //错误的
//    public void show(String ... info,String i){
//
//    }


}

知识点7：方法参数的值传递机制

1. 变量的传递机制：

*  1. 如果传递的是基本数据类型的变量，则将变量本身保存的数据值传递过去
*  2. 如果传递的是引用数据类型的变量，则将变量本身保存的地址值传递过去

public class VariableTest {

    public static void main(String[] args) {
        int m = 10;
        //对于基本数据类型变量来说：
        int n = m;
        n = 20;
        System.out.println("m = " + m);//10

        //对于引用数据类型变量来说：
        Order o1 = new Order();
        o1.num = 10;
        //
        Order o2 = o1;
        o2.num = 20;

        System.out.println("o1.num = " + o1.num);

        //
        int[] array1 = new int[]{2,3,5,7,11};
        int[] array2 = array1;
        array2[0] = 0;
        System.out.println(array1[0]);//0

    }
}
class Order{
    int num;
}

2. 方法形参的值传递机制

*  1. 形参：方法声明时，小括号内的参数。
*     实参：方法调用时，实际传递给形参的数据
*
*  2. 如果方法的形参是基本数据类型的变量，则将实参保存的数据值传递给形参变量。
*     如果方法的形参是引用数据类型的变量，则将实参保存的地址值传递给形参变量。

• 基本数据类型

public class ValueTransferTest {
    public static void main(String[] args) {
        int m = 10;
        int n = 20;

        System.out.println("m = " + m + ", n = " + n);

        //交换两个变量的值
//        int temp = m;
//        m = n;
//        n = temp;
        ValueTransferTest test = new ValueTransferTest();
        test.swap(m,n);

        System.out.println("m = " + m + ", n = " + n);
    }

    public void swap(int m ,int n){
        int temp = m;
        m = n;
        n = temp;
    }
}

对应图示：

• 引用数据类型

public class ValueTransferTest1 {

    public static void main(String[] args) {
        Data data = new Data();
        data.m = 10;
        data.n = 20;
        System.out.println("m = " + data.m +", n = " + data.n);

        //交换的操作
        ValueTransferTest1 test = new ValueTransferTest1();
        test.swap(data);
        System.out.println("m = " + data.m +", n = " + data.n);

        System.out.println(data);//com.atguigu.java1.Data@1540e19d

//        User user = data;
    }

    public void swap(Data data1){
        int temp = data1.m ;
        data1.m = data1.n;
        data1.n = temp;
    }
}
class Data{
    int m ;
    int n;
}

class User{

}

对应图示：

3. 练习1

/**
 * @author shkstart
 * @create 2020-07-01 16:23
 */
public class ValueTransferTest2 {

    public static void main(String[] args) {

        int[] arr = new int[]{34, 4, 2, 6, 6, 4, 7, -87, 0, 55, 98};

        System.out.println(Arrays.toString(arr));

        ValueTransferTest2 test = new ValueTransferTest2();
        test.sort(arr, "ascend");

        System.out.println(Arrays.toString(arr));

    }

    public void sort(int[] arr, String sortMethod) {
        if ("ascend".equals(sortMethod)) {//从小到大
            for (int i = 0; i < arr.length - 1; i++) {
                for (int j = 0; j < arr.length - 1 - i; j++) {
                    if (arr[j] > arr[j + 1]) {
                        //最初的写法：正确
//                        int temp = arr[j];
//                        arr[j] = arr[j + 1];
//                        arr[j + 1] = temp;
                        //错误的写法
//                        swap(arr[j], arr[j + 1]);
                        //正确的写法
                        swap(arr,j,j+1);
                    }
                }
            }

        } else if ("descend".equals(sortMethod)) {//从大到小
            for (int i = 0; i < arr.length - 1; i++) {
                for (int j = 0; j < arr.length - 1 - i; j++) {
                    if (arr[j] < arr[j + 1]) {
                        //最初的写法：正确
//                        int temp = arr[j];
//                        arr[j] = arr[j + 1];
//                        arr[j + 1] = temp;
                        //错误的写法
//                        swap(arr[j], arr[j + 1]);
                        //正确的写法
                        swap(arr,j,j+1);
                    }
                }
            }
        } else {
            System.out.println("排序方式错误！");
        }
    }

//    public void swap(int i,int j){
//        int temp = i;
//        i = j;
//        j = temp;
//    }

    public void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

4.练习2：

public class TransferTest3 {
    public static void main(String args[]) {
        TransferTest3 test = new TransferTest3();
        test.first();
    }
    public void first() {
        int i = 5;
        Value v = new Value();
        v.i = 25;
        second(v, i);
        System.out.println(v.i);
    }
    public void second(Value v, int i) {
        i = 0;
        v.i = 20;
        Value val = new Value();
        v = val;
        System.out.println(v.i + " " + i);
    }
}

class Value {
    int i = 15;
}

对应的图示：

补充内容：

NullPointerException的理解

/**
 *  关于面向对象内容中的NullPointerException的说明：
 *  凡是引用数据类型的变量（对象、数组）,如果取值为null时，通过此变量调用其内部结构的话，一定就是
 *  NullPointerException的异常。
 *
 * @author shkstart
 * @create 2020-07-01 9:15
 */
public class NullPointerExceptionTest {
    public static void main(String[] args) {
        User u1 = new User();
//        u1 = null;
//        u1.name = "孔江江";
//        u1.show();
        System.out.println(u1.name);
//        System.out.println(u1.name.toString());
    }
}

class User{
    String name;
    int age;
    public void show(){
        String str = null;
        System.out.println("我是一个用户");
    }
}

对象数组的理解

/**
 * 定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。
 * 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
 * 问题一：打印出3年级(state值为3）的学生信息。
 * 问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
 *
 * 提示：
 * 1) 生成随机数：Math.random()，返回值类型double;
 * 2) 四舍五入取整：Math.round(double d)，返回值类型long。
 *
 * @author shkstart
 * @create 2020-07-01 11:56
 */
public class StudentArrayTest {
    public static void main(String[] args) {
        int[] arr = new int[10];
        String[] arr1 = new String[10];

//      创建20个学生对象
        Student[] stus = new Student[20];//虚位以待
        for (int i = 0; i < stus.length; i++) {
            stus[i] = new Student();
            //给每一个学生的属性赋值
            //学号
            stus[i].number = i + 1;
            //年级：1-6
            stus[i].state = (int)(Math.random() * 6 + 1);
            //成绩：0-100
            stus[i].score = (int)(Math.random() * 101);
        }

        //问题一：打印出3年级(state值为3）的学生信息。
//        for (int i = 0; i < stus.length; i++) {
//            if(stus[i].state == 3){
//                stus[i].info();
//            }
//        }
        //问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
        for(int i = 0;i < stus.length - 1;i++){
            for(int j = 0;j < stus.length - 1 - i;j++){
                if(stus[j].score > stus[j + 1].score){
                    Student temp = stus[j];
                    stus[j] = stus[j + 1];
                    stus[j + 1] = temp;
                }
            }
        }

        for (int i = 0; i < stus.length; i++) {
            stus[i].info();
        }
    }
}

class Student{
    int number;//学号
    int state;//年级
    int score;//成绩

    public void info(){
        System.out.println("number : " + number + ", state : " + state + ", score : " + score);
    }
}

• 对应的内存解析