Java之类 #类的属性 #类的方法（#方法的重载 #可变形参的方法 #方法参数的值传递机制 #递归方法）-CFANZ编程社区

类的成员之——属性

语法格式：

修饰符数据类型属性名 = 初始化值 ;

说明1: 修饰符

常用的权限修饰符有：private、缺省、protected、public

其他修饰符：static、final (暂不考虑)

说明2：数据类型

任何基本数据类型(如int、Boolean) 或任何引用数据类型。

说明3：属性名

属于标识符，符合命名规则和规范即可。

 public class Student{
        public String name;
        private int age = 18;
    }

属性（成员变量）与局部变量

1.相同点：
        1.1 定义变量的格式：数据类型变量名 = 变量值
       1.2 先声明，后使用
       1.3 变量都有其对应的作用域
2.不同点：
       2.1 在类中声明的位置的不同
       属性：直接定义在类的一对{}内
       局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量

        2.2 关于权限修饰符的不同
        属性：可以在声明属性时，指明其权限，使用权限修饰符。
常用的权限修饰符：private、public、缺省、protected --->封装性
        局部变量：不可以使用权限修饰符。

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

        2.4 在内存中加载的位置：
        属性：加载到堆空间中（非static）
        局部变量：加载到栈空间

类的成员之——方法

方法的声明格式

修饰符返回值类型方法名（参数类型形参1, 参数类型形参2, ….）｛

方法体程序代码

return 返回值;

｝

说明

1 权限修饰符：Java规定的4种权限修饰符：private、public、缺省、protected
2 返回值类型： 有返回值 vs 没有返回值
    2.1 如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用return关键字来返回指定类型的变量或常量：“return 数据”。
    2.2 如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中，就不需要使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。
3 方法名：属于标识符，遵循标识符的规则和规范，“见名知意”
4 形参列表： 方法可以声明0个，1个，或多个形参。
   4.1 格式：数据类型1 形参1,数据类型2 形参2,...
   4.2 我们定义方法时，该不该定义形参？（具体问题具体分析）
5 方法体：方法功能的体现。
6 return关键字的使用：
  6.1 使用范围：使用在方法体中
  6.2 作用：① 结束方法
② 针对于有返回值类型的方法，使用"return 数据"方法返回所要的数据。
  6.3 注意点：return关键字后面不可以声明执行语句
7 方法的使用中，可以调用当前类的属性或方法
   7.1 特殊的：方法A中又调用了方法A:递归方法。
   7.2 方法中，不可以定义方法。

方法的重载

定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
遵循原则：两同一不同原则：同一个类、相同方法名；参数列表不同：参数个数不同，参数类型不同

Test ：比较三个数，输出其中最大数（运用方法重载，可满足不同类型）

class GetMax{
    public static void main(String[] args) {
        GetMax test = new GetMax();
        System.out.println(test.getMax(11, 22, 33));
    }
    public int getMax(int i,int j,int c){
        int max =  (i > j) ? i : j;
        return (max > c) ? max : c;
    }

    public double getMax(double i,double j,double c){
        double max =  (i > j) ? i : j;
        return (max > c) ? max : c;
    }
}

方法的可变个数的形参（jdk 5.0新增的内容）

1 可变个数形参的格式：数据类型 ... 变量名
2 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。
3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
4 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
5 可变个数形参在方法的形参中，必须声明在末尾
6 可变个数形参在方法的形参中,最多只能声明一个可变形参。

public class MethodArgs {
    public static void main(String[] args) {
        MethodArgs test = new MethodArgs();
        test.print(12);
        test.print("12");
        test.print("12","13","14");
        //等同于上边
        test.print(new String[]{"12","13","14"});
    }

    public void print(int i){
        System.out.println("输入的【" + i + "】为int类型");
    }

    public void print(String s){
        System.out.println("输入的【" + s + "】为String类型");
    }

    public void print(String ... str){
        for (int i = 0; i < str.length; i++) {
            System.out.println("输入的【" + str[i]  + "】为String...类型");
        }
    }

   /*不能与上一个方法同时存在
    public void print(String[] str){
        System.out.println("输入为String...类型");
    }*/
}

//  public void print(String ...str,int i){  //可变个数形参必须放在末尾
    public void print(int i,String ...str){
        System.out.println("可变个数形参必须放在末尾");
    }

方法参数的值传递机制（值传递）

方法，必须由其所在类或对象调用才有意义。若方法含有参数：

形参：方法定义时，声明的小括号内的参数
实参：方法调用时，实际传递给形参的数据

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

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

class ValueTransfer{
    public static void main(String[] args) {
        Student1[] arr = new Student1[10];//声明Student1类型的数组
        for (int i = 0; i < arr.length; i++) {
            arr[i] = new Student1();//给数组元素赋值
            arr[i].score = (int)(Math.random() * (100-0 +1) +0);//给Student1对象的属性（成绩）赋值（0-100的随机数）
        }
        //按成绩冒泡排序
        ValueTransfer test = new ValueTransfer();
        for (int i = 0; i < arr.length -1; i++) {
            for (int j = 0; j < arr.length -1 -i; j++) {
                //如果需要换序，交换的是数组的元素：Student对象！！！（不要把成绩交换了）
                if (arr[j].score > arr[j+1].score){
//                    test.swap(j,j+1);  //所以属于基本数据类型 为数据值传递 不能通过中间变量交换（比如a=10,b=a,b=20,a=?还是10）
//                    test.swap(arr[i],arr[i+1]);//数组的元素是基本数据类型 是数据值传递
                    test.swap(arr,j,j+1);//引用数据类型是地址值传递
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i].score);
        }
    }

    /**
     * @description 交换数组中指定位置的二个元素的值
     * @author ALvin
     * @date 2022年1月11日10:18:38
     * param
     */
    public void swap(int i,int j){
        int temp = i;
        i = j;
        j = temp;
    }
    public void swap(Student1 i,Student1 j){
        Student1 temp = i;
        i = j;
        j = temp;
    }
    public void swap(Student1[] st,int i,int j){
        Student1 temp = st[i];
        st[i] = st[j];
        st[j] = temp;
    }
}

class Student1{
    int score;//成绩
}

递归方法

递归方法：一个方法体内调用它自身

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

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

class Recursion{
    public static void main(String[] args) {
        Recursion test = new Recursion();
        System.out.println(test.getSum(3));
    }
    public int getSum(int n){
        if(n == 1){
            return 1;
        }else {
            return n * getSum(n-1);
        }
    }
}

说明：本篇文章部分内容和图片引用尚硅谷官网内容，特此说明。@尚硅谷官网地址