Java基础 DAY10

方法重载（overload）

重载介绍

基本介绍：Java中允许同一个类，多个同名方法的存在，但要求形参列表不一致。
例如：System.out.println(); out是PrintStream类型
重载的好处：
1）减轻了起名的麻烦
2）减轻了记名的麻烦

重载快速入门

public class class1 {
    //编写一个main方法
    public static void main(String[] args) {

        // System.out.println(100);
        // System.out.println("hello,world");
        // System.out.println('h');
        // System.out.println(1.1);
        // System.out.println(true);
        //
        MyCalculator mc = new MyCalculator();
        System.out.println(mc.calculate(1, 2));
        System.out.println(mc.calculate(1.1, 2));
        System.out.println(mc.calculate(1, 2.1));
    }
}

class MyCalculator  {
    //下面的四个 calculate方法构成了重载
    //两个整数的和
    public int calculate(int n1, int n2)  {
        System.out.println("calculate(int n1, int n2) 被调用");
        return n1 + n2;
    }

    //没有构成方法重载, 仍然是错误的，因为是方法的重复定义
    // public void calculate(int n1, int n2)  {
    // 	System.out.println("calculate(int n1, int n2) 被调用");
    // 	int res =  n1 + n2;
    // }

    //下面是否构成重载, 没有构成重载，而是方法的重复定义,所以错了
    // public int calculate(int a1, int a2)  {
    // 	System.out.println("calculate(int n1, int n2) 被调用");
    // 	return a1 + a2;
    // }

    //一个整数，一个double的和
    public double calculate(int n1, double n2) {
        return n1 + n2;
    }
    //一个double ,一个int和
    public double calculate(double n1, int n2) {
        System.out.println("calculate(double n1, int n2) 被调用..");
        return n1 + n2;
    }
    //三个int的和
    public int calculate(int n1, int n2,int n3) {
        return n1 + n2 + n2;
    }

}

重载使用细节

注意事项和使用细节：
1）方法名：必须相同
2）形参列表：必须不同（形参类型或个数或顺序，至少有一样不同，参数名无要求）

重载课堂练习

练习1：

练习2:

public class class1 {
    //编写一个main方法
    public static void main(String[] args) {
        Methods methods = new Methods();
        methods.m(10);
        methods.m(10, 20);
        methods.m("hello");

    }
}

class Methods{
    public void m(int a){
        //1.方法名m
        //2.形参（int）
        //3.void
        System.out.println("平方后的结果=" + (a * a));
    }
    //1 方法名 m
    //2 形参 (int, int)
    //3.void
    public void m(int n1, int n2) {
        System.out.println("相乘=" + (n1 * n2));
    }

    //1 方法名 m
    //2 形参 (String)
    //3.void
    public void m(String str) {
        System.out.println("传入的str=" + str);
    }


}

练习3：

public class class1 {
    //编写一个main方法
    public static void main(String[] args) {
        Methods method = new Methods();
  
        System.out.println(method.max(10, 24)); // 24
        System.out.println(method.max(10.0, 21.4)); // 21.4
        System.out.println(method.max(10.0, 1.4, 30.0)); // 30.0
    }
}

class Methods{
    //1 方法名 max
    //2 形参 (int,int)
    //3.int
    public int max(int n1, int n2) {
        return n1 > n2 ? n1 : n2;
    }

    //1 方法名 max
    //2 形参 (double,double)
    //3.double
    public double max(double n1, double n2) {
        return n1 > n2 ? n1 : n2;
    }

    //1.方法名 max
    //2 形参 (double,double,double)
    //3.double
    public double max(double n1, double n2, double n3) {

        System.out.println("max(double n1, double n2, double n3)");
        //求出n1 和  n2的最大值
        double max1 = n1 > n2 ? n1 : n2;
        return max1 > n3 ? max1 : n3;
    }

    public double max(double n1, double n2, int n3) {

        System.out.println("max(double n1, double n2, int n3)");
        //求出n1 和  n2的最大值
        double max1 = n1 > n2 ? n1 : n2;
        return max1 > n3 ? max1 : n3;
    }


}

可变参数

基本概念：
Java允许将同一个类中多个同名同功能 但参数个数不同的方法，封装成一个方法，就可以通过可变参数实现。

基本语法：
访问修饰符 返回类型 方法名（数据类型… 形参名）{
}

快速入门案例：
类Method,方法sum(可以计算两个数的和，三个数的和。。)

public class class1 {

    //编写一个main方法
    public static void main(String[] args) {

        HspMethod m = new HspMethod();
        System.out.println(m.sum(1, 5, 100)); //106
        System.out.println(m.sum(1,19)); //20
    }
}

class HspMethod {
    //可以计算 2个数的和，3个数的和 ， 4. 5， 。。
    //可以使用方法重载
    // public int sum(int n1, int n2) {//2个数的和
    // 	return n1 + n2;
    // }
    // public int sum(int n1, int n2, int n3) {//3个数的和
    // 	return n1 + n2 + n3;
    // }
    // public int sum(int n1, int n2, int n3, int n4) {//4个数的和
    // 	return n1 + n2 + n3 + n4;
    // }

    //上面的三个方法名称相同，功能相同, 参数个数不同-> 使用可变参数优化
    //1. int... 表示接受的是可变参数，类型是int ,即可以接收多个int(0-多)
    //2. 使用可变参数时，可以当做数组来使用 即 nums 可以当做数组
    //3. 遍历 nums 求和即可
    public int sum(int... nums) {
        //System.out.println("接收的参数个数=" + nums.length);
        int res = 0;
        for(int i = 0; i < nums.length; i++) {
            res += nums[i];
        }
        return res;
    }
}

可变参数细节

public class VarParameterDetail { 

	//编写一个main方法
	public static void main(String[] args) {
		//细节: 可变参数的实参可以为数组
		int[] arr = {1, 2, 3};
		T t1 = new T();
		t1.f1(arr);
	}
}

class T {

	public void f1(int... nums) {
		System.out.println("长度=" + nums.length);
	}

	//细节: 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
	public void f2(String str, double... nums) {

	}
	//细节: 一个形参列表中只能出现一个可变参数
	//下面的写法是错的.
	// public void f3(int... nums1, double... nums2) {

	// }
}

课堂练习：

public class class1 {

    //编写一个main方法
    public static void main(String[] args) {
        Method hm = new Method();
        System.out.println(hm.showScore("milan" , 90.1, 80.0 ));
        System.out.println(hm.showScore("terry" , 90.1, 80.0,10,30.5,70 ));
    }
}

class Method  {
	/*
	有三个方法，分别实现返回姓名和两门课成绩(总分)，
	返回姓名和三门课成绩(总分)，
	返回姓名和五门课成绩（总分）。
	封装成一个可变参数的方法
	 */

    //分析1. 方法名 showScore
    // 2. 形参(String ,double... )
    // 3. 返回String
    //听课小伙伴，老师要求必须自己动手写
    public String  showScore(String name ,double... scores ) {

        double totalScore = 0;
        for(int i = 0; i < scores.length; i++) {
            totalScore += scores[i];
        }
        return name + " 有 " +scores.length + "门课的成绩总分为=" + totalScore;
    }
}

作用域（scope）

public class VarScope { 

	//编写一个main方法
	public static void main(String[] args) {
	}
}
class Cat {
	//全局变量：也就是属性，作用域为整个类体 Cat类：cry eat 等方法使用属性
	//属性在定义时，可以直接赋值
	int age = 10; //指定的值是 10

	//全局变量(属性)可以不赋值，直接使用，因为有默认值，
	double weight;  //默认值是0.0

	public void hi() {
		//局部变量必须赋值后，才能使用，因为没有默认值
		int num = 1;
		String address = "北京的猫";
		System.out.println("num=" + num);
		System.out.println("address=" + address);
		System.out.println("weight=" + weight);//属性
	}
	
	public void cry() {
		//1. 局部变量一般是指在成员方法中定义的变量
		//2. n 和  name 就是局部变量
		//3. n 和 name的作用域在 cry方法中
		int n = 10;
		String name = "jack";
		System.out.println("在cry中使用属性 age=" + age);
	}

	public void eat() {

		System.out.println("在eat中使用属性 age=" + age);
		

		//System.out.println("在eat中使用 cry的变量 name=" + name);//错误
	}
}

注意事项和细节使用

public class VarScopeDetail { 

	//编写一个main方法
	public static void main(String[] args) {
		Person p1 = new Person();
		/*
		属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。
		局部变量，生命周期较短，伴随着它的代码块的执行而创建，
		伴随着代码块的结束而销毁。即在一次方法调用过程中
		 */
		//p1.say();//当执行say方法时，say方法的局部变量比如name,会创建，当say执行完毕后
		//name局部变量就销毁,但是属性(全局变量)仍然可以使用
		//
		T t1 = new T();
		t1.test(); //第1种跨类访问对象属性的方式

		t1.test2(p1);//第2种跨类访问对象属性的方式

	}
}

class T {

	//全局变量/属性：可以被本类使用，或其他类使用（通过对象调用)
	public void test() {
		Person p1 = new Person();
		System.out.println(p1.name);//jack
	}

	public void test2(Person p) {
		System.out.println(p.name);//jack
	}
}

class Person {
	//细节: 属性可以加修饰符(public protected private..)
	//      局部变量不能加修饰符
	public int age = 20;

	String name = "jack";

	public void say() {
		//细节 属性和局部变量可以重名，访问时遵循就近原则
		String name = "king";
		System.out.println("say() name=" + name);
	}

	public void hi() {
		String address = "北京";
		//String address = "上海";//错误,重复定义变量
		String name = "hsp";//可以
	}
}

构造器

public class Constructor01 { 

	//编写一个main方法
	public static void main(String[] args) {
		//当我们new 一个对象时，直接通过构造器指定名字和年龄
		Person p1 = new Person("smith", 80);
		System.out.println("p1的信息如下");
		System.out.println("p1对象name=" + p1.name);//smith
		System.out.println("p1对象age=" + p1.age);//80
	}
}

//在创建人类的对象时，就直接指定这个对象的年龄和姓名
//
class Person {
	String name;
	int age;
	//构造器
	
	//1. 构造器没有返回值, 也不能写void
	//2. 构造器的名称和类Person一样
	//3. (String pName, int pAge) 是构造器形参列表，规则和成员方法一样
	public  Person(String pName, int pAge) {
		System.out.println("构造器被调用 ，完成对象的属性初始化");
		name = pName;
		age = pAge;
	}
}

注意事项及使用细节

public class ConstructorDetail { 

	//编写一个main方法
	public static void main(String[] args) {
		Person p1 = new Person("king", 40);//第1个构造器
		Person p2 = new Person("tom");//第2个构造器

		Dog dog1 = new Dog();//使用的是默认的无参构造器

	}
}
class Dog {
	//如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器(也叫默认构造器)
	//使用javap指令 反编译看看
	/*
		默认构造器
		Dog() {
			
		}
	 */
	//一旦定义了自己的构造器,默认的构造器就覆盖了，就不能再使用默认的无参构造器，
	//除非显式的定义一下,即:  Dog(){}  写 (这点很重要)
	//
	public Dog(String dName) {
		//...
	}
	Dog() { //显式的定义一下 无参构造器

	}
}

class Person {
	String name;
	int age;//默认0
	//第1个构造器
	public Person(String pName, int pAge) {
		name = pName;
		age = pAge;
	}
	//第2个构造器, 只指定人名，不需要指定年龄
	public Person(String pName) {
		name = pName;
	}
}