方法与重载

知识点:

定义带参数的方法

<访问修饰符> 返回类型 <方法名>(<形式参数列表>) {
//方法的主体 --形参-- 参数是什么？
}

方法传参

基本数据类型和引用数据类型数据在传参时区别

基本数据类型，操作传递的是变量的值，改变一个变量的值不会影响另一个变量的值。引用数据类型（类、数组和接口），赋值是把原对象的引用（可理解为内存地址）传递给另一个引用

构造方法

访问修饰符 构造方法名 ( ) {
//初始化代码
}

无返回值类型 方法名与类名相同 可以指定参数 系统提供默认无参构造方法

构造方法重载

自定义构造方法 方法名相同 参数项不同 与返回值、访问修饰符无关

方法重载----->同名不同参

注释：如果类中有构造方法,系统将不在提供无参构造,如果类中没有构造方法,系统会自动生成一个无参构造

this关键字的用法

调用属性 this.health = 100;

调用方法 this.print();

调用构造方法：

​ this();

​ this(“小黑”,100,100,“雄”);

方法重载

同一个类中
方法名相同
参数个数或类型不同
与返回值、访问修饰符无关

成员变量和局部变量 ----成员变量 类中方法外

变量声明的位置决定变量作用域

变量作用域确定可在程序中按变量名访问该变量的区域

成员变量和局部变量的区别

作用域不同

局部变量的作用域仅限于定义它的方法
成员变量的作用域在整个类内部都是可见的

初始值不同

Java会给成员变量一个初始值
Java不会给局部变量赋予初始值

注释: 在同一个方法中，不允许有同名局部变量在不同的方法中，可以有同名局部变量

注释: 在同一个类中，成员变量和局部变量同名时，局部变量具有更高的优先级

面向对象三大特征之一 ——封装

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问

封装的两个大致原则

把所有的属性藏起来 把尽可能多的东西藏起来，对外提供便捷的接口

封装的好处

为什么需要包

文档分门别类，易于查找和管理
使用目录解决文件同名冲突问题

包命名规范

包名由小写字母组成，不能以圆点开头或结尾

包名之前最好加上唯一的前缀，通常使用组织倒置的网络域名

包名后续部分依不同机构内部的规范不同而不同

使用包的注意事项

一个类同时引用了两个来自不同包的同名类
必须通过完整类名来区分
每个包都是独立的，顶层包不会包含子包的类
package和import的顺序是固定的
package必须位于第一行（忽略注释行）第一行有效代码
只允许有一个package语句
其次是import
接着是类的声明

类成员的访问修饰

作用域****修饰符	同一个类中	同一个包中	子类中	任何地方
private	可以	不可以	不可以	不可以
默认修饰符	可以	可以	不可以	不可以
protected	可以	可以	可以	不可以
public	可以	可以	可以	可以

static修饰符

static可以用来修饰
成员变量
静态变量，可以直接通过类名访问
成员方法
静态方法，可以直接通过类名访问
代码块
静态代码块，当Java虚拟机加载类时，就会执行该代码块

JVM加载类时，加载静态代码块
如果有多个静态块，按顺序加载
每个静态代码块只会被执行一次

static变量

类的成员变量包括
类变量（静态变量）
被static修饰的变量
在内存中只有一个拷贝
类内部，可在任何方法内直接访问静态变量
其他类中，可以直接通过类名访问
实例变量
没有被static修饰的变量
每创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响

static方法

静态方法：可直接通过类名访问
静态方法中不能使用this和super
不能直接访问所属类的实例变量和实例方法
可直接访问类的静态变量和静态方法
实例方法：通过实例访问
可直接访问所属类的静态变量、静态方法、实例变量和实例方法
静态方法必须被实现

如何使用继承

继承是Java中实现代码重用的重要手段之一。Java中只支持单根继承，即一个类只能有一个直接父类

（1）使用super关键字,super代表父类对象
（2）在子类构造方法中调用且必须是第一句
（3）不可以访问父类中定义为private的属性和方法

super关键字来访问父类的成员
super只能出现在子类的方法和构造方法中
super调用构造方法时，只能是第一句
super不能访问父类的private成员

继承条件下的构造方法

继承条件下构造方法的调用规则
子类构造方法没有通过super显式调用父类的有参构造方法，也没通过this显式调用自身其他构造方法
系统默认调用父类的无参构造方法
子类构造方法通过super显式调用父类的有参构造方法
执行父类相应构造方法，而不执行父类无参构造方法
子类构造方法通过this显式调用自身的其他构造方法，在相应构造方法中应用以上两条规则

子类继承父类的什么？

继承public和protected修饰的属性和方法，不管子类和父类是否在同一个包里
继承默认权限修饰符修饰的属性和方法，但子类和父类必须在同一个包里

---

练习代码：

public class StudentBiz {
	
	 String [] names = new String [30];
	 
	 public void addName(String name) {
		 for (int i = 0; i < names.length; i++) {
			if(names[i]==null) {
				 names[i]=name;
				 break;
			}
		}
	 }
	 public void showNames() {
		 System.out.println("本班学生列表:");
		 for (int i = 0; i < names.length; i++) {
			if(names[i]!=null) {
				System.out.println(names[i]+"\t");
			}
		}
		 System.out.println();
	 }
	 public boolean searchName(int start,int end,String name) {
		 boolean find=false;
		 //指定区间数组,查找姓名
		 for (int i = start-1; i < end; i++) {
			if(names[i].equals(name)) {
				find=true;
				break;
			}
		}
		return find;
	 }
}

public class TestSearch {
	public static void main(String[] args) {
		StudentBiz st = new StudentBiz();
		Scanner input=new Scanner(System.in);
		for(int i=0;i<5;i++) {
			System.out.println("请输入学生姓名：");
			String newName=input.next();
			st.addName(newName);
		}
		st.showNames();
		System.out.println("请输入开始查找的位置：");
		int s=input.nextInt();
		System.out.println("请输入结束查找的位置：");
		int e=input.nextInt();
		System.out.println("请输入要查找的姓名：");
		String name=input.next();
		System.out.println("**********查找结果****************");
		if(st.searchName(s, e, name)) {
			System.out.println("找到了");
		}else {
			System.out.println("不存在");
		}
		
	}
}

---

public class Student {
	public String name;
	public int age;
	public String sex;
	public int xid;
	
	public Student(String name, int age, String sex, int xid) {
		super();
		this.name = name;
		this.age = age;
		this.sex = sex;
		this.xid = xid;
	}

	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + ", sex=" + sex + ", xid=" + xid + "]";
	}
	
}

public class Test01 {
	public static void main(String[] args) {
		Student stu1 = new Student("张三", 18,"女", 777777);
		System.out.println(stu1);
	}
}

public class Test02 {
	//方法的重载 同名不同参
	public int getSum(int num1,int num2) {
		System.out.println("int");
		return num1+num2;
	}
	
	public double getSum(double num1,double num2) {
		System.out.println("double");
		return num1+num2;
	}

	public double getSum(double num1,double num2,double num3) {
		System.out.println("double");
		return num1+num2+num3;
	}
	public static void main(String[] args) {
		Test02 t1 = new Test02();
		System.out.println(t1.getSum(1, 5));
		System.out.println(t1.getSum(6.4, 3.4));
		System.out.println(t1.getSum(6.7, 6.5, 3.3));
	}
}

---

public class Voter {
	private static int count;//所有选民都会改变同一个数据：投票的次数
	private static final int MAX_COUNT=100;//最大投票数100 适用所有选民
	private static String name;
	public Voter(String name) {
		this.name=name;
	}
	//投票
	public void voteFor() {
		if(count==MAX_COUNT) {
			System.out.println("投票活动已结束");
			return ;
		}else {
			count++;
			System.out.println(this.name+"感谢您投票！");
		}
	}
	//打印投票结果
	public static void printResult() {
		System.out.println("选民投票的总数为："+count);
		//不能访问实例变量
	}
}

public class TestVoter {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Voter zhang = new Voter("张三");
		Voter lisi = new Voter("李四");
		Voter wangwu = new Voter("王五");
		
		Voter.printResult();
		
		zhang.voteFor();
		lisi.voteFor();
		wangwu.voteFor();
		
		for(int i =1;i<=97;i++) {
			Voter v = new Voter("V"+i);
			v.voteFor();
		}
		Voter v101 = new Voter("v101");
		v101.voteFor();
		Voter.printResult();
	}

}

---

public class Dog extends Pet{
	private String strain="哈士奇";//犬种

	public Dog() {
		System.out.println("子类无参构造方法");
	}

	public Dog(String name, String strain) {
		super(name);
		this.strain=strain;
		System.out.println("子类带参数的构造方法");
	}

	public String getStrain() {
		return strain;
	}

	public void setStrain(String strain) {
		this.strain = strain;
	}

	@Override
	public String toString() {
		return "Dog [strain=" + strain + "]";
	}

public class Penguin extends Pet{
	private String sex="Q仔";

	public Penguin() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Penguin(String name,String sex) {
		super(name);
		this.sex=sex;
		System.out.println("子类企鹅类带参构造方法");
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

	@Override
	public String toString() {
		return "Penguin [sex=" + sex + "]";
	}
	
	
}

public class Pet {
	private String name="无名氏";//昵称
	private int health=100;//健康值
	private int love=20;//亲密度
	public Pet(String name) {
		super();
		this.name = name;
	}
	public Pet() {
		super();
		// TODO Auto-generated constructor stub
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getHealth() {
		return health;
	}
	public void setHealth(int health) {
		if(health<0||health>100) {
			System.out.println("请正确输入宠物的健康值：");
			this.health=60;
			return ;
		}
		this.health = health;
	}
	public int getLove() {
		return love;
	}
	public void setLove(int love) {
		if(love<0||love>100) {
			System.out.println("请正确输入宠物的亲密度：");
			this.love=60;
			return ;
		}
		this.love = love;
	}
	
	@Override
	public String toString() {
		return "Pet [name=" + name + ", health=" + health + ", love=" + love + "]";
	}
	
	
}

public class Test01 {
	//1.创建宠物对象Pet 并输出信心
	public static void main(String[] args) {
		Pet pet = new Pet("贝贝");
		System.out.println(pet.toString());
	//2.创建狗类的对象 并输出
		Dog dog =new Dog();
		dog.setName("巴雷特");
		dog.setHealth(90);
		dog.setLove(70);
		dog.setStrain("斗牛犬");
		System.out.println(	dog.toString());
	//3.创建企鹅对象 并输出信息
		Penguin pgn = new Penguin();
		pgn.setName("奥巴马");
		pgn.setHealth(98);
		pgn.setLove(99);
		pgn.setSex("Q妹");
		System.out.println(pgn.toString());
		
		Dog dog2 = new Dog("来福","萨摩耶");
		System.out.println(dog2.toString());
		Penguin pgn2 = new Penguin("花藤","Q妹");
		System.out.println(pgn2.toString());

	}
}

---

public class Dog extends Pet{
	
	private String strain; //品种

	public Dog() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Dog(String name,String strain) {
		super(name); //此处不能使用 this.name =name
		this.strain = strain;
	}

	public String getStrain() {
		return strain;
	}

	public void setStrain(String strain) {
		this.strain = strain;
	}

	@Override
	public String toString() {
		return "Dog [strain=" + strain + "]";
	}
	
	public void test() {
		//不能继承private成员
		//System.out.println(name);
		//同包下,可以继承protected修饰的成员
		System.out.println(color);
		//同包下,子类可以继承默认修饰的成员
		System.out.println(avoirdupois);
		//子类可以继承 public 修饰的成员
		System.out.println(id);
	}
}

public class Pet {
	private   String name="无名氏";  //昵称
	private   int  health =100;		// 健康值
	private  int love =0;			//亲密度
	
	//以下属性是测试访问权限及集成情况
	int avoirdupois =2;  //重量
	protected String color; //颜色
	public int id =1001;
	
	public Pet() {
		this.health=95;
		System.out.println("执行宠物的无参构造方法!");
	}
	/**
	 * 有参构造方法  只留了一个name属性
	 * @param name
	 */
	public Pet(String name) {
		super();
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getHealth() {
		return health;
	}
	public void setHealth(int health) {
		this.health = health;
	}
	public int getLove() {
		return love;
	}
	public void setLove(int love) {
		this.love = love;
	}
	public int getAvoirdupois() {
		return avoirdupois;
	}
	public void setAvoirdupois(int avoirdupois) {
		this.avoirdupois = avoirdupois;
	}
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	@Override
	public String toString() {
		return "Pet [name=" + name + ", health=" + health + ", love=" + love + ", avoirdupois=" + avoirdupois
				+ ", color=" + color + ", id=" + id + "]";
	}

}

public class Test {

	public static void main(String[] args) {
		//同包下 可以使用protected成员
		 System.out.println(new Pet().color);
		 //公共 成员
		 System.out.println(new Pet().id);

	}

}

---

public class Student {
	public String  name;
	private String sex="女";
	int age=18;
	protected int xid;
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student(String name, String sex, int age, int xid) {
		super();
		this.name = name;
		this.sex = sex;
		this.age = age;
		this.xid = xid;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		if(age<18||age>30) {
			System.out.println("请输入正确的年龄");
			return;
		}
		this.age = age;
	}
	public int getXid() {
		return xid;
	}
	public void setXid(int xid) {
		this.xid = xid;
	}
	
	//方法
	//1 私有方法
	private void ff1() {}
	//默认修饰符修饰的方法
	void ff2() {}
	//同包修饰符 修饰的方法
	protected void  ff3() {}
	//公共的方法
	public void ff4() {
		System.out.println(name+"说:好好学习天天向上!");
	}	
}

public class TestStudent {

	public static void main(String[] args) {
		
		Student  stu = new Student();
		stu.ff2();
		stu.ff3();
		stu.ff4();
		//默认的访问修饰符 修饰的 属性 可以在同包下调用		
		stu.age=18;
		stu.name="张三";
		stu.xid=00544;
	}
}