java中的方法重载、覆盖、构造方法、扫描仪

方法重载（Overload）： 方法过载，一种方法有多种含义(功能)

​ 方法重载的条件：（面试题）

​ 1.需要在同一个类中

​ 2.方法名相同

​ 3.方法的参数需要不同（参数类型不同or参数个数不同or参数顺序不同）

​ **注：**1）参数名不同不能算是不同

​ 2）方法重载对修饰符和返回类型没有要求

​ public static void test(){}

​ public int test(int x){}

​ 方法重载的作用？

​ 为了同时满足用户的不同需求

方法覆盖（Override）： 方法重写

​ 方法覆盖的条件：（面试题）

​ 需要发生在有继承关系的两个类中，而且是在子类中实现，在子类重写父类的方法，从而达到覆盖父类方法的效果

public void test()throws Exception{}
| |
脑袋----躯干---------尾巴

（脑袋）权限： 子类的访问权限修饰符 >= 父类的权限

（躯干）返回类型： jdk5.0之前：必须相同 jdk5.0之后：协变

​ 方法签名： 必须一样

​ 一般子类的实现的方法更加优秀，权限应该更广泛，便于更多人使用

（尾巴）异常处理部分： 子类异常 <= 父类的异常（范围小于等于）

​ 异常：程序执行的过程中，可能出现的隐患

​ 一般子类的实现的方法更加优秀，隐患应该尽量的少

jdk5.0开始，方法覆盖的时候，可以在子类要覆盖的方法上面加@Override注解，用来提示计算机下面的方法一定要覆盖父类的某个方法

jdk5.0开始 方法覆盖的时候 其实返回类型可以改变了
可以变成父类方法返回类型的子类类型 -》 协变返回类型

方法重载和方法覆盖的区别？（面试题）

不同点	方法重载	方法覆盖
含义不同	Overload	Overide
发生的位置不同	同一个类中	有继承关系的两个类中
对返回类型的要求不同	没有要求	jdk5.0之前：相同 jdk5.0之后：协变
对参数的要求不同	参数不同[类型/个数/顺序]	参数相同
作用不同	同时满足不同需求	让方法变优秀

	//异常：Exception
	/*小：ArrayIndexOutOfBoundsException:A
	    NullPointerException:N
	    ClassNotFondException:C*/

	//父类：
	public void test()throws Exception{}

	//子类：
	public void test()throws A,N,C{}

异常解决方法：

​ throws ：抛还上级

​ try catch ：自行处理

super.方法名/属性 在子类调用一下父类的某个方法/属性

super()调用父类方法，this()调用本类方法

构造方法： 创建对象时调用的方法-》收尾工作

构造方法的作用？

​ 1）构造方法语法的出现是为了方便程序员的开发

​ 2）可以通过传参直接给属性赋值（一次性给多个属性赋值）

Java中只要有类就有构造方法，即使我们没有构造，系统也会提供一个默认的构造方法：无参 空体 没有给属性赋值

如果想要在创建对象的同时直接给属性赋值的话，需要自己写一个构造方法，此时的默认构造方法就会被新的构造方法顶替掉

构造方法和普通方法的区别？

​ 1）构造方法没有返回类型 ->修饰符+方法签名

​ 2）构造方法名与类名相同

构造方法的首行：
默认：super()：要执行本构造方法之前 先去执行父类的构造方法
具体执行父类的哪一个构造方法，看参数类型
默认找无参构造方法

如果父类没有无参构造方法：
1：提供父类的无参构造方法
2：在super()里面传参数 指定他找父类的哪一个构造方法

构造方法的首行还可以出现this():
this():表示要执行本构造方法之前 先去执行本类的
其他的构造方法 具体执行本类的哪一个构造方法
看参数类型

构造方法能不能方法重载？ 可以

构造方法能不能方法覆盖？ 不能
构方法不能被子类继承

public class Exec1{
public static void main(String[] args){
   User user = new User("lady","123456");
   System.out.println(user.getName()+"  "+user.getPassword()+"  " +user.getUserId());
  user.setUserId("u123");
  System.out.println(user.getUserId());
}}
class User{
private 	String name;
private String password;
private String userId;
public void setName(String name){//可以随机修改某个属性，与构造方法中的赋值不冲突
	this.name=name;
	}
public String getName(){
	return name;}
public void setPassword(String password){
	this.password=password;
	}
public String getPassword(){
	return password;}
public void setUserId(String userId){
	this.userId=userId;
	}
public String getUserId(){
	return userId;}
public  User(String name,String password){//一次性给多个属性赋值
	this.name=name;
	this.password=password;
	this.userId= ""+(char)(Math.random() * 26 + 65)+(int)(Math.random()*900+100);
		}
	}

扫描仪：
Scanner scan = new Scanner(System.in);
String s = scan.next();
int age =scan.nextInt();

import java.util.*;
public class TestScanner{
public static void main(String[] args){
	System.out.println("请输入您的名字");
	Scanner sc=new Scanner(System.in);
	String name=sc.nextLine();
	System.out.println("请输入您的年龄");
	int age =sc.nextInt();
	System.out.println("请选择您的性别[A:女   B:男]");
	String AB=sc.next();
	char gender =AB .equals('A')?'女':'男';
	System.out.println("请输入你的工资");
	double salary =sc.nextDouble();
	Teacher tea=new Teacher(name,age,gender,salary);
}
}
class Teacher{
	String name;
	int age;
	char gender;
	double salary;
	public Teacher(String name,int age, char gender,double salary){
		this.name=name;
		this.age=age;
		this.gender=gender;
		this.salary=salary;
		System.out.println(name+"老师，性别"+gender+",今年"+age+"岁了，工资是￥"+salary+"元");
		}}

封装、继承、多态、方法重载、方法覆盖综合案例：

public class Zongheanli{
	public static void main(String[] args){
		Person per1=new Person("小王",'女');
		 Doctor  per2=new Doctor ("Tom",'男',8000);
		Cat cat =new Cat("杰瑞");
		RestRoom rr=new RestRoom();
		rr.service(per1);
		rr.service(per2);
		rr.service(cat);
		per2.cure();
		System.out.println(per2.getSalary());


		}
}
class Person{
	private String name;//封装
	private char gender;
	public void setName(String name){
		this.name=name;
		}
		public String getName(){
			return name;}
	public void setGender(char gender){
			this.gender=gender;
			}
	public char getGender(){
			return gender;}
	public Person(String name,char gender){
		this.name=name;
		this.gender=gender;
		}
	public void eat(){
		System.out.println("人类吃食物");
		}
	public  void sleep(){
		System.out.println("人需要保证8小时的睡眠");
		}
	}

	class Doctor  extends Person{//继承
		private double salary;
		public void setSalary(double salary){
				this.salary=salary;
				}
		public double getSalary(){
			return salary;}
		public  Doctor(String name, char gender,double salary){//构造方法
			super(name,gender);
			this.salary=salary;
			}
			public void eat(){
					System.out.println("医生吃绿色食品");//方法覆盖
					}
			public void cure(){
						System.out.println("医生会治病");
					}
		}

		class Cat{
			private String name;
			public void setName(String name){
				this.name=name;
				}
			public String getName(){
					return name;
				}
				public Cat(String name){
					this.name=name;
					}
			public void find(){
				System.out.println("猫会捉老鼠");
				}
			}
class RestRoom{
	public void service(Person  person){
		System.out.println("请"+person.getName()+(person.getGender()=='男'?"先生":"女士")+"上"+person.getGender()+"厕所");//三目实现
		}
	public  void service(Cat  cat){
				System.out.println("请"+cat.getName()+"出去");//方法重载
		}
	}

三目嵌三目实例：

public class exec1{
public static void main(String [] args){
	Crime c=new Crime("人",'女');
	Crime a=new  Crime("猫",'男');
	RestRoom re=new RestRoom();
	re.service(c);
	re.service(a);
}
}
class Crime{
	String name;
	char gender;
	public Crime(String name,char gender){
			this.name=name;
			this.gender=gender;
		}
	}
class RestRoom{
	public void service(Crime c){
			System.out.println("请"+c.name+(c.name=="人"? c.gender=='男'?  "先生请上"+c.gender+"厕所":"女士请上"+c.gender+"厕所"      :"出去"));//三目嵌三目
		}
	}