Java基础第十一课——类与对象（2）

由于类与对象这一部分的知识点很多，而且操作方法也有很多，所以这次将继续深入讨论一下关于类与对象中方法传参、方法重载、构造方法以及this关键字使用方面的知识。

一、方法传参

1.return关键字

return关键字作用

作用场景：方法内

作用：

1）结束方法，返回到方法调用处

2）结束方法并返回一个结果给方法调用者

注意：return在方法内结束后续操作的作用与break在循环结构中的作用表现一致

package com.kgc.se.demo01;

/**
 * @JdkVersion: 17
 * @Author: 二白程序员
 * @Date 2024/4/12 8:49
 * QQ：1512015112
 * VX：18056394367
 */


public class ReturnDemo01 {

  
    public static void m1(int num){
        //在输出结果之前，判断你传递进来的参数num是否大于50，如果大于50，就给计算机一个提示，不输出这个结果，结束方法后续代码的执行

        if(num>50){
            return;
        }



        System.out.println(num);
    }

    public static void m2(int num){
        if (num<1){
            return;
        }
        for (int i=1;i<=num;i++ ){
            //输出i的值，如果i的值为5，就结束方法的执行
            if (i==5){
                return;
            }
            System.out.println(i);
        }
    }



}

package com.kgc.se.demo01;

/**
 * @JdkVersion: 17
 * @Author: 二白程序员
 * @Date 2024/4/12 8:51
 * QQ：1512015112
 * VX：18056394367
 */


public class ReturnDemo01Test {
    public static void main(String[] args) {
        ReturnDemo01.m1(100);

        System.out.println("方法调用完毕");

        ReturnDemo01.m2(10);
    }
}

2.数组方面的应用

前言：3大引用数据类型：数组、类、接口

类：是一种自己定义的数据类型，类是一个模板，模板中定义了属性和方法，通过这个模板创建出来的对象都会拥有这个类中定义的属性和方法

根据类创建的对象中可以存储各种属性值，对象就可以看成是一个容器，这个容器就可以存储不同类型的数据（属性的数据类型是不同）

类是一种数据类型，根据类创建出来的多个对象，可以存储在数组中

语法：数据类型[] 数组名={数据1，数据2，……，数据n}；

例：

package com.kgc.se.demo02;

/**
 * @JdkVersion: 17
 * @Author: 二白程序员
 * @Date 2024/4/12 9:01
 * QQ：1512015112
 * VX：18056394367
 */


public class ObjectArray01 {
   
    public static void main(String[] args) {
        //创建3个Student类对象
        Student student1 = new Student();
        student1.name="张三";
        student1.age=20;
        student1.gender='男';
        Student student2 = new Student();
        student2.name="李四";
        student2.age=22;
        student2.gender='男';
        Student student3 = new Student();
        student3.name="小芳";
        student3.age=18;
        student3.gender='女';



        //将上面3个Student类对象存储到数组中
        Student[] students ={student1,student2,student3};

        //遍历输出student数组中的所有元素
        for (int i = 0; i < students.length; i++) {
            //从students数组里取出的元素是一个一个的Student类对象，既然是对象，就可以调用属性、调用方法

            System.out.print(students[i].name+"-");
            System.out.print(students[i].age+"-");
            System.out.print(students[i].gender+"\n");

            //上面输出取出来的对象的信息，是一个属性一个属性去调用的，也可以直接通过对象来输出所有属性值

            System.out.println("***************************");
            for (Student stu:students){
                stu.showInfo();
            }

            System.out.println("***************************");
            students[i].showInfo();
            System.out.println("***************************");


        }
    }



}

package com.kgc.se.demo02;

/**
 * @JdkVersion: 17
 * @Author: 二白程序员
 * @Date 2024/4/12 9:04
 * QQ：1512015112
 * VX：18056394367
 */


public class Student {
    public String name;
    public  int age;
    public  char gender;

    public void showInfo(){
        System.out.println(name+"-"+age+"-"+gender);
    }
}

例：

package com.kgc.se.demo02;

/**
 * @JdkVersion: 17
 * @Author: 二白程序员
 * @Date 2024/4/12 9:49
 * QQ：1512015112
 * VX：18056394367
 */


public class StudentUtilsTest {
    public static void main(String[] args) {
        Student student1 = new Student();
        student1.name="张三";
        student1.age=20;
        student1.gender='男';
        Student student2 = new Student();
        student2.name="李四";
        student2.age=22;
        student2.gender='男';
        Student student3 = new Student();
        student3.name="小芳";
        student3.age=18;
        student3.gender='女';
        Student student4 = new Student();
        student4.name="小红";
        student4.age=16;
        student4.gender='女';
        Student student5 = new Student();
        student5.name="王五";
        student5.age=22;
        student5.gender='男';
        Student student6 = new Student();
        student6.name="张港澳";
        student6.age=23;
        student6.gender='女';
        Student student7 = new Student();
        student7.name="张富康";
        student7.age=22;
        student7.gender='女';

        Student[] students1={student1,student2,student3,student4,student5,student6,student7,};

        //查找students1数组中0-6范围内是否有张三这个学生
        boolean  result= StudentUtils.findStudentName(students1,0,6,"张三");
        System.out.println("你要查找的数组的指定区间里有你要查找的学生姓名： " + result);

    }
}

package com.kgc.se.demo02;

/**
 * @JdkVersion: 17
 * @Author: 二白程序员
 * @Date 2024/4/12 9:41
 * QQ：1512015112
 * VX：18056394367
 */


public class StudentUtils {


    //定义一个静态方法，实现在Student类型的数组中，查找指定区间内是否有指定的学生姓名,如果有，返回true，没有则返回false

    public static boolean findStudentName(Student[] students,int startIndex,int endIndex,String name){
        //遍历students数组的指定区间，从这个区间中查找是否有姓名为name的学生
        for (int i = startIndex;i<=endIndex;i++){
            //比较范围内的Student对象姓名和你要查找的学生姓名
            if (name.equals(students[i].name)){
                return true;
            }

        }
        return false;

    }



}

二、方法重载

方法重载：

在一个类中，多个方法的方法名相同，参数列表不同的现象，就是方法重载

方法重载的要求：

1）在同一个类中

2）方法名相同

3）参数列表不同（参数的类型不同，参数的个数不同，参数的顺序不同）

4）与方法的返回值类型无关

5）与方法的访问权限修饰符无关

public class Calc {
    //这是一个计算器类，类中有多个方法实现加法运算

    //定义一个求两个int类型数据之和的方法
    public  int sum(int num1,int num2){
        return num1+num2;
    }

    //定义一个求三个int数据之和的方法
    public  int sum2(int num1,int num2,int num3){
        return num1+num2+num3;
    }

    //定义一个求两个double类型数据之和的方法
    public double sum(double sum1,double sum2){
        return sum1+sum2;
    }


    //定义一个int类型数据和一个double类型数据之和的方法
    public double sum(int num1,double num2){
        return num1+num2;
    }

    //定义一个求double类型数据和一个int类型数据之和的方法
    public double sum(double num1,int num2){
        return num1+num2;
    }



}

三、构造方法

构造方法：

作用：用来创建对象的

构造方法的特点：

1）构造方法名与类名相同

2）构造方法没有返回值，void也不写

3）当你定义好一个类的时候，系统自动为这个类添加一个无参的构造方法，并且隐藏起来了

4）当你在类中添加了其它构造方法后，会覆盖系统默认添加的无参构造方法，如果这时候你需要使用无参构造方法，你就需要手动添加一个无参构造方法，否则会报错

5）当一个类中有多个构造方法时，会构成方法重载现象

例：

package com.kgc.se.demo05;

/**
 * @JdkVersion: 17
 * @Author: 二白程序员
 * @Date 2024/4/12 11:05
 * QQ：1512015112
 * VX：18056394367
 */


public class Test {

    public static void main(String[] args) {


        //创建一个int类型变量并输出
        int a = 100;
        System.out.println("a="+a);//a=100
        //创建一个Student类对象并赋值age为20

        //类名 对象名= new 类名();
        Student stu = new Student();
        stu.age = 10;
        System.out.println("stu的年龄："+stu.age);//stu的年龄：10


        //创建Demo类对象，调用Demo类中的两个方法
        Demo demo = new Demo();
        //调用m1()方法
        demo.m1(a);//m1()方法中对传递过来的值进行操作后，值为：101

        System.out.println("a="+a);//a=100

        System.out.println("---------------");

        demo.m2(stu);
        System.out.println("stu的年龄："+stu.age);//stu的年龄：11

        int[] nums = {11,22,33};
        System.out.println(nums);
        System.out.println(stu);

        System.out.println("-----------------------");

        //使用Student类中的有参构造方法创建对象
        Student student = new Student(20);
        System.out.println(student.age);





    }
}

package com.kgc.se.demo05;

/**
 * @JdkVersion: 17
 * @Author: 二白程序员
 * @Date 2024/4/12 11:05
 * QQ：1512015112
 * VX：18056394367
 */

public class Student {

    
    public Student(){}

    public Student(int a){
        age =a;
    }

    public int age;
}

四、this关键字

每调用一次该构造方法，就应该将传递的参数赋值给当前对象，但是每次创建的对象名是不同的，所以需要一个标识来指向每次创建的对象，这个标识就是this关键字

this关键字表示当前对象，谁调用这个构造方法，this就指向谁，表示谁

例：

package com.kgc.se.demo06;

/**
 * @JdkVersion: 17
 * @Author: 二白程序员
 * @Date 2024/4/12 11:16
 * QQ：1512015112
 * VX：18056394367
 */


public class GirlFriend {

    public String name;
    public int age;
    public char gender;
    public double height;
    public double weight;
    public String hobby;
    public String address;

    //在类中添加了有参构造方法之后，默认的无参构造方法会被覆盖，所以手动添加一个无参构造方法
    public GirlFriend(){}

    //添加一个只包含对象name属性和age属性的有参构造方法
//    public  GirlFriend(String a,int b){
//        name =a;
//        age=b;
//    }

    //添加一个有参构造方法
//    public GirlFriend(String a,int b,char c,double d, double e,String f,String g){
//        name =a;
//        age=b;
//        gender =c;
//        height=d;
//        weight =e;
//       hobby= f;
//       address =g;
//    }

    //上面两个有参构造方法的形参列表中形参的名字没有做到见面之意，在调用方法时不便于知道各个参数的含义，所以修改形参名
    public  GirlFriend(String name,int age){
//        name =name;
//        age=age;
        //上面形参实现了见名知意，但是在创建对象时发现，传递过来的参数没有赋值给所创建对象的对应属性中，那么因为代码内部，将传递过来的参数又赋值给了自己本身，没有指明赋值给所创建的对象
        
        this.name=name;
        this.age=age;
    }

    public GirlFriend(String name,int age,char gender,double height, double weight,String hobby,String address){
//        name =name;
//        age=age;
//        gender =gender;
//        height=height;
//        weight =weight;
//        hobby= hobby;
//        address =address;
        this.name =name;
        this.age=age;
        this.gender =gender;
        this.height=height;
        this.weight =weight;
        this.hobby= hobby;
        this.address =address;
    }



    //定义方法
    public void printInfo(){
        System.out.println(name+"-"+age+"-"+gender+"-"+height+"-"+weight+"-"+hobby+"-"+address);
    }


}

package com.kgc.se.demo06;

/**
 * @JdkVersion: 17
 * @Author: 二白程序员
 * @Date 2024/4/12 11:19
 * QQ：1512015112
 * VX：18056394367
 */


public class GirlFriendTest {

    public static void main(String[] args) {

        //使用GirlFriend类中默认存在的无参构造方法创建对象
        GirlFriend girlFriend1 = new GirlFriend();
        //给创建出来的girlfriend1对象的属性赋值
        girlFriend1.name = "小芳";
        girlFriend1.age =18;
        girlFriend1.gender = '男';
        girlFriend1.height = 165.5;
        girlFriend1.weight = 52.2;
        girlFriend1.hobby = "打男朋友";
        girlFriend1.address = "安徽";

        //输出girlfriend1对象的信息
        girlFriend1.printInfo();

        System.out.println("------------------------------");

        //使用Girlfriend类中的有参构造方法创建对象
        GirlFriend girlfriend2 = new GirlFriend("小红",20,'男',160.3,80.5,"拳击","安徽");
        //输出girlfriend2对象的信息
        girlfriend2.printInfo();

        GirlFriend girlFriend3 = new GirlFriend("小绿",60);
        //输出girlfriend3对象的信息
        girlFriend3.printInfo();

        GirlFriend girlFriend4 = new GirlFriend("小黄",20,'女',170.1,51.3,"打篮球","安徽");
        girlFriend4.printInfo();
    }
}