【JavaSE】面向对象——属性和方法

学习面向对象的三条主线

1.Java类及类的成员：属性，方法，构造器； 代码块、内部类
2.面向对象的三大特征：封装、继承、多态，（抽象性）
3.其他关键字：this,super,static,final,abstract,interface,package...

基本元素：类和对象

类是对一类事物的描述，是抽象的（比如人）
对象是实际存在的该类事物的每个个体（比如人的具体化）

面向对象程序设计的重点就是类的设计
设计类，就是设计类的成员

属性和方法

属性 = 成员变量 = field = 域、字段
方法 = 成员方法 = 函数（C语言中） = method
创建类的对象 = 类的实例化 = 实例化类

属性使用

属性（成员变量）和局部变量的对比：

相同点：

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

不同点：

在类中声明的位置不同：属性直接定义在类的{}内；局部变量声明在方法内、方法形参、代码块、构造器内部的变量。如下

public void talk(String language) {  //language是形参，是局部变量
        System.out.println("我们使用" + language + "进行交流");
    }
    
    public void eat() {
        String food = "烙饼"; //局部变量
        System.out.println("我喜欢吃" + food);
    }

权限修饰符不同：
属性可以在声明属性时，指明其权限，使用权限修饰符；

局部变量不可以使用权限修饰符（最多可以使用final）。

默认初始化值的情况：
属性：类的属性，根据其类型，都有默认初始化值。

整形（byte,short,int,long）:0
浮点型（float,double）:0.0
字符型（char）:0（或'\u0000'）
布尔型（boolean）:false
引用数据类型（类，接口，数组）:null
局部变量：没有默认初始化值。意味着我们在调用局部变量之前，一定要显式赋值。
特别的：形参调用时赋值即可。

加载的位置不同

属性：加载到堆空间中（static会放在方法区）
局部变量：加载到栈空间

类中方法的声明和使用

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

比如：Math类，Scanner类，Arrays类
举例：

class Customer{
        //属性
        String name;
        int age;
        boolean isMale;

        //方法
        public void eat() {
                System.out.println("客户吃饭");
        }

        public void sleep(int hour) {
                System.out.println("休息了" + hour + "个小时");
        }

        public String getName() {
                return name;
        }

        public String getNation(String nation) {
                String info = "我的国籍是" + nation;
                return info;
        }
}

上面代码中
public void eat(){}
public void sleep(int hour){}
public String getName()
public String getNation(String nation)
就是我们定义的方法，而{}中的代码，就是方法体；
另外，上面四个方法中void表示无返回类型，String代表有返回值，返回类型为Srting，相同的，int表示返回类型为整形；
()中的是形参，可以自行定义

总结：

方法的声明：

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

具体说明：

权限修饰符：private,public,缺省，protected

返回值类型：
①如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法体中，需要使用return关键字来返回指定类型的变量或者常量。

②如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中，就不使用return。但是，如果使用的话，只能"return;"表示结束此方法的意思。
③根据题目要求看需要不要有返回值。

方法名：就是一个标识符，写方法名时要遵循标识符的规则和规范，做到“见名知意”
形参列表：方法可以声明0及0以上个形参；写形参时我们只能声明，不能赋值。只有调用此方法时才给具体值。
方法体：方法功能的体现

return关键字的使用：

使用范围：使用在方法体中
作用：①结束方法②针对有返回值类型的方法，使用"return 数据"的方式返回所要的数据。
注意点：return后面不可以声明执行语句。

方法的使用中，可以调用当前类的属性或方法。比如上面代码中，可以在sleep方法体中，可以调用Customer类中其他方法（如eat()）。特殊的：方法A中调用方法A，我们成为递归方法。
我们不能在方法中，再定义一个方法。

类和对象的使用（面向对象思想落地）

比如我设计一个人的类，代码如下：

 class Person{

 }

但我们说设计类就是设计类的成员，那么我们就可以在“人”这个类中添加成员，即属性和方法。
下面我们就在Person类中添加类的成员

 class Person{

        //属性
        String name;
        int age;
        boolean isMale;

        //方法
        public void eat() {
                System.out.println("人可以吃饭");
        }

        public void sleep() {
                System.out.println("人可以睡觉");
        }

        public void talk(String language) {
                System.out.println("人可以说话，使用的是" + language);
        }
}

我在Perosn类中添加了三个属性和三个方法
属性中：我加了一个姓名name（String类型），年龄age（int类型），isMale是否为男性（布尔类型），该三个变量都没有初始化。
方法中：我加了吃，睡，说话三个方法。在说话talk方法中，我添加了一个参数，该参数是String类型，变量名叫language，这样当我们调用这个方法的时候，就可以传递参数，比如talk(Chinese)，打印出来的就是“人可以说话，使用的是Chinese”。

类及类的成员已经创建好了，接下来就是我们如何在主（main）方法中去调用类里面的成员，既然是面向对象编程，那就一定是在主方法中创建类的对象。下面是创建过程。

//创建Person类的对象
Person p1 = new Person();

p1是对象的名字，可以自行定义，这一行代码的意思就是，既然你要Person类的对象，就去new Person()，左右两边都要有，这是规定。

既然对象创建好了，那么我们的目的，使用类中的属性和方法就可以实现了，下面是实现举例：

    //创建Person类的对象
    Person p1 = new Person();
    
    //调用属性的语法：“对象.属性”
    p1.name = "Tom";
    p1.isMale = true;
    p1.age = 1;
    System.out.println(p1.name);
    
    //调用方法的语法：“对象.方法”
    p1.eat();
    p1.sleep();
    p1.talk("Chinese");

如果我们再创建一个Person对象，比如叫p2，当我们再打印p2.name的时候，就不能是“Tom”了而是null，因为“Tom”只针对p1。每造一个对象，都是类的一次实例化，与其他对象无关。
但如果造一个对象等于p1，比如 Person p3 = p1;那么在打印p3.name的时候就是“Tom”了。这是将p1变量保存的地址值赋给p3，导致p1和p3指向了堆空间中的同一个对象实体。

以上我们总结为：

创建类：设计类的成员
创建类的对象：new
通过"对象.属性或方法"的方式，调用对象的结构
如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性（非static）。意味着：如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。

匿名对象的使用

还是以上面的Person类为例子，我们在主函数内创建对象的方法是 Person p1 = new Person();
然后通过p1调用属性和方法，比如p1.name; p1.eat();
那么匿名对象的调用方法格式就是"new 类名.属性或方法;" 比如new Person.eat();
需要注意的是，我们每用一次匿名对象，就相当于创建一个新的对象，而p1每一次调用都是通过p1这个实实在在的对象调用的。
👇总结：

我们创建的对象，没有显式地赋给一个变量名。即为匿名对象。
特征：匿名对象只能调用一次。

再谈方法

方法的重载

🎈概念

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

即“两同一不同”：
同一个类，相同方法名；
参数列表不同:参数个数不同，参数类型不同。

🎈特点

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

注意：跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系!
👇例题

1.编写程序定义三个重载方法并调用。方法名mOL。
三个方法分别接受一个int参数、两个int参数、一个字符串参数。
分别执行平方运算并输出结果，相乘并输出结果，输出字符串信息。
在主类的mian()方法中分别用参数区别调用三个方法。

       public void mOL(int i) {
        System.out.println(i * i);
    }
    
    public void mOL(int i, int j) {
        System.out.println(i * j);
    }
    
    public void mOL(String s) {
        System.out.println(s);
    }

2.定义三个重载方法max()，
第一个方法求两个int值中的最大值，
第二个方法求两个double值中的最大值，
第三个方法求三个double值中的最大值。

        public int max(int i ,int j) {
        return (i > j)? i : j;
    }
    
        public double max(double d1 ,double d2) {
        return (d1 > d2)? d1 : d2;
    }
    
        public double max(double d1 ,double d2,double d3) {
        double max = (d1 > d2)? d1 : d2;
        return (max > d3)? max : d3?
    }

提醒：如果方法直接写在刚开始创建的类中，那么要调用这些方法，还是直接创建方法所在类中的对象。

可变个数的形参

🎈格式

数据类型 ... 变量名

例如：

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

调用可变个数形参的方法时，传入的参数个数可以是0及0以上个。
可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载。

方法参数的值传递机制

🎈了解变量的赋值

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

🎈理解形参实参

形参：方法声明时的参数
实参：方法调用时实际传给形参的参数值

✨值传递机制

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

👇举例：交换两数的值

    public class ValueTransferTest {
            public static void main(String[] args) {
                    //基本数据类型
                    int m = 10;
                    int n = 20;
                    System.out.println("m = " + m + ", n = " + n);
                    //交换两个变量的值的操作
                    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 ValueTransferTest {
    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);
        //交换两个变量的值的操作
        ValueTransferTest test = new ValueTransferTest();
        test.swap(data);
        System.out.println("m = " + data.m + ", n = " + data.n);
    }
    
    public void swap(Data data) {
        int temp = data.m;
        data.m = data.n;
        data.n = temp;
    }
}

class Data{
    int m;
    int n;
}

👇举例2：打印

       public static void main(String[] args) {
        int [] arr = new int[] {1,2,3};
        System.out.println(arr); //地址值
        
        char[] arr1 = new char[] {'a','b','c'};
        System.out.println(arr1); //打印出abc而不是地址值
    }

递归方法

🎈定义

一个方法体内调用它自身

注意：

方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。

递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。

🌹例题

例1：
比如我们要打印1-100之间所有自然数的和
我们有两种方式：①for循环②方法递归

👇下面就用递归来写

public class RecursionTest {
    public static void main(String[] args) {
        //例子1：计算1-100之间所有自然数的和
        RecursionTest test = new RecursionTest();
        int sum = test.getSum(100);
        System.out.println(sum);
    }
    
    public int getSum(int  n) {
        if(n == 1) {
            return 1;
        } else {
            return n + getSum(n-1);
        }
    }
}

例2：斐波那契数列
输入一个数据n，计算斐波那契数列的第n个值 1 1 2 3 5 8 13 21 34 55
规律：一个数等于前两个数之和

public class RecursionTest {
    public static void main(String[] args) {
        //例2：输出第n个斐波那契数列值
        RecursionTest test = new RecursionTest();
        int value = test.f(9);
        System.out.println(value);
    }
    
    public int f(int  n) {
        if(n <= 2) {
            return 1;
        } else {
            return f(n-1) + f(n-2);
        }
    }
}