Java基础面向对象（一）

一、类和对象

类是对一类事物的描述，是抽象的、概念上的定义

对象时实际存在的该类事物的每一个个体，也称为实例

二、类的成员

1. 属性：类中的成员变量
2. 行为：类中的成员方法
3. 构造器
4. 代码块
5. 内部类

三、类和对象的创建

1. 使用步骤

1. 创建类：设计类的成员
2. 创建类的对象
3. 通过对象.属性或对象.方法调用对象的结构

package com.example.www;

public class PersonTest {
    public static void main(String[] args) {
        // 创建Person类的对象(实例化一个类)
        Person p1 = new Person();
        // 调用对象的属性 对象.属性
        p1.name = "Tom";
        System.out.println(p1.name);
        // 调用对象的方法 对象.方法
        p1.eat();
        p1.talk("Chinese");

    }
}


// 类的创建
class Person {
    // 属性
    String name;
    int age;
    // 方法
    public void eat(){
        System.out.println("eat...");
    }
    public void talk(String language){
        System.out.println(language);
    }
}

如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性（非static的）。

2. 匿名对象

1. 创建的对象没有显式的赋值给一个变量

2. 只能调用一次

public class PhoneTest {
    public static void main(String[] args) {
        new Phone().sendMsg();
        new Phone().playGame();
        // 这个两个不同的对象
    }
}

class Phone{
    public void sendMsg(){
        System.out.println("发短信");
    }
    public void playGame(){
        System.out.println("玩游戏");
    }
}

四、属性

属性和局部变量的区别：

相同点：

1. 定义变量的格式：数据类型 变量名 = 变量值
2. 先声明后使用
3. 变量都有其对应的作用域

不同点：

1. 在类中声明的位置不同
   1. 属性：直接定义在类的一对{}内
   2. 局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
2. 关于权限修饰符的不同
   1. 属性：可以在声明属性时，指明其权限。常用的权限修饰符：private、public、缺省、protected。
   2. 局部变量：不可以使用权限修饰符。
3. 默认初始化值
   1. 属性：根据其类型，都有默认初始化值
   2. 局部变量：没有默认初始化值，在调用局部变量之前一定要显式赋值。
4. 在内存中加载的位置
   1. 属性：加载到堆空间中（非static）
   2. 局部变量：加载到栈空间中

五、方法

方法：描述类应该具有的功能。

1. 方法的声明

权限修饰符 返回值类型 方法名(形参列表){
    方法体;
}

1. 权限修饰符（4种）：private、public、缺省、protected
2. 返回值
   1. 如果方法有返回值，则必须在方法声明时指定返回值类型，同时方法中需要使用return关键字来返回指定类型的变量或常量。
   2. 如果方法没有返回值，则方法声明时使用void来表示。通常在没有返回值的方法中，就不能使用return关键字，如果使用的话只能使用return;来表示此方法结束。
3. 方法名：属于标识符，遵循标识符的规则和规范。
4. 形参列表：方法可以声明0个、1个或多个形参。数据类型1 形参1, 数据类型2 形参2...
5. 方法体：方法功能的实现

2.return关键字

1. 使用范围：使用在方法体中
2. 作用：
   1. 结束方法
   2. 针对于有返回值类型的方法，使用return 数据返回所要的数据。
3. return关键字后面不可以声明执行语句

3. 方法的使用

1. 方法在使用中，可以调用当前类的属性或方法
2. 方法中不能定义方法

4. 方法重载

在一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

与返回值类型无关，只看参数列表，且参数列表必须不同，调用时，根据方法参数列表的不同来区别。

判断方法是否重载，和方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系。

5. 可变个数的形参

允许直接定义能和多个实参向匹配的形参，从而可以用一种更简单的方式来传递个数可变的实参。

格式：数据类型 ... 变量名

当调用可变个数形参的方法时，传入的参数个数可以是0个，1个或多个。

可变个数形参的方法与本类中方法名相同、形参不同的方法之间构成重载。

可变个数形参在方法的形参中，必须声明在末尾。

可变个数形参在方法的形参中，最多只能声明一个可变形参。

public class MethodArgsTest {
    public static void main(String[] args) {
        MethodArgsTest test = new MethodArgsTest();
        test.show("Hello");
        test.show("Hello", "World");
//        test.show(new String[]{"Hello", "World"});
    }
//    public void show(String[] strs) {
    public void show(String ... strs){
        System.out.println(strs);
        for (int i = 0; i < strs.length; i++) {
            System.out.println(strs[i]);
        }
    }
}

6. 方法参数的值传递机制

Java中方法的参数传递方式只有一种：值传递。即将实际参数值的副本传入方法内，而参数本身不受影响。

1. 形参是基本数据类型，将实参基本数据类型变量的"数据值"传递给形参
2. 形参是引用数据类型，将实参引用数据类型变量的"地址值"传递给形参

6.1 方法中变量的赋值：

1. 如果变量是基本数据类型，此时赋值的是变量所保存的数据值

2. 如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

public class ValueTransferTest {
    public static void main(String[] args) {
        int m = 10;
        int n = m;
        System.out.println("m = " + m + ", n = " + n); // m = 10, n = 10
        n = 20;
        System.out.println("m = " + m + ", n = " + n); // m = 10, n = 20
        User user1 = new User();
        user1.name = "Tom";
        User user2 = user1; // user1和user2的地址值相同
        System.out.println("user1.name = " + user1.name + ", user2.name = " + user2.name); // user1.name = Tom, user2.name = Tom
        user2.name = "Jerry";
        System.out.println("user1.name = " + user1.name + ", user2.name = " + user2.name); // user1.name = Jerry, user2.name = Jerry
    }
}

class User{
    String name;
}

6.2 方法的形参值传递机制

1. 形参：方法定义时，声明在小括号内的参数
2. 实参：方法调用时实际传递给形参的值。

值传递机制

1. 如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。
2. 如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。

例：参数是基本数据类型

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

        ValueTransferTest test = new ValueTransferTest();
        test.swap(m, n);

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

    }

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

例：参数是引用数据类型

public class ValueTransferTest {
    public static void main(String[] args) {

        Data data = new Data();
        data.m = 10;
        data.n = 20;
        
        ValueTransferTest test = new ValueTransferTest();
        test.swap(data);
        System.out.println("m = " + data.m + ", n = " + data.n); // m = 20, n = 10
    }
    public void swap(Data data){
        int tmp = data.m;
        data.m = data.n;
        data.n = tmp;
    }
}

class Data{
    int m;
    int n;
}

7. 递归

1. 递归求和

public class RecursionTest {
    public static void main(String[] args) {
        int sum = new RecursionTest().getSum(100);
        System.out.println(sum);
    }
    public int getSum(int n) {
        if (n == 1){
            return 1;
        }else{
            return n + getSum(n-1);
        }
    }
}

2. 斐波那契数列

public class FibonacciTest {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            long num = fibanacci(i);
            System.out.print(num + " ");
        }
    }
    public static long fibanacci(long number) {
        if (number == 0 || number == 1){
            return number;
        }else{
            return fibanacci(number -1 ) + fibanacci(number - 2);
        }
    }
}

3. 汉诺塔

// https://blog.csdn.net/ljmingcom304/article/details/50296939
public class HanoiTower {
    public static void hanoi(int n, String a, String b,String c) {
        if (n == 1) {
            // 只有一个圆盘时直接从A石柱移动到C石柱
            move(n, a, c);
        } else {
            // 将前n-1个圆盘从石柱A移动到石柱B
            hanoi(n - 1, a, c, b);
            // 将第n号圆盘从石柱A移动到石柱C
            move(n, a, c);
            // 将前n-1个圆盘从石柱B移动到石柱C
            hanoi(n - 1, b, a, c);
        }
    }

    public static void move(int n, String i, String j) {
        System.out.println("第" + n + "个圆盘，" + "从" + i + "移动到" + j);
    }

    public static void main(String[] args) {
        hanoi(3,"A","B","C");
    }
}