学习java第八天

一.方法重写/方法覆盖/Override

为什么要进行方法重写/覆盖？

子类不满足父类的逻辑，进行重写

方法重写的注意事项：

1.方法重写前提是必须要继承

2.所继承的方法名必须一致，方法参数也要一致

举例说明一个方法的三部分

public void eat(){}

第一部分 头部 

访问权限修饰符 public protected default private 

除了父类的private 其他子类的访问权限 >=父类的访问权限

Sun公司认为子类的方法更优秀 ，更优秀的方法应该被更多人看到，所以子类访问权限>=父类的访问权限

特例： 父类private时，子类不能继承父类的private修饰的方法

如果父类为 protected 那么子类可以是protected 或者public

第二部分 躯干

返回类型+方法签名[方法名+参数]  一模一样子类和父类，返回类型 方法签名都是一样的

对于jdk1.5以后的版本，返回类型可以不一样

第三部分  尾部

异常处理

必须对其进行捕获或声明以便抛出 有两种

第一种、try catch 自行处理【提供解决方案】

第二种、throws 抛走【让上级处理】

Exception 是最大的异常

Sun公司认为 子类重写的方法更优秀，隐患更少，所以子类的异常处理要小于等于父类中的异常处理

父类：throws Exception

子类：throws 比父类要小的异常

Jdk5.0之后

1. 方法覆盖的时候可以加 @Override
2. [非重点] *-返回类型允许改变 返回类型可以改变成  协变返回类型 [父类类型的子类类型]

@Override 注解  给机器看的 校验有没有方法覆盖重写父类中的方法

【一个Override只认一个方法】

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

1. 含义不同

2. 方法覆盖Override

   方法重载 Overload

3. 发生的位置不同

4. 方法覆盖发生在有继承关系的两个类中 而且肯定是子类中

   方法重载发生在同一个类中

5. 方法参数  

6. 方法覆盖一模一样  

   方法重载 方法参数必须不同 类型 顺序 个数

7. 返回类型  

8. 方法重载 跟返回类型无关    

   方法覆盖一模一样 jdk5.0以后返回类型可以改变成协变【父类类型的子类类型】

9. 作用不同  

10. 方法覆盖 让方法更优秀

    方法重载 满足更多用户不同需求

 super

super ->超级/超类/父类

父类的属性 方法

super.research();

二.构造方法

什么是构造方法？

构造方法是创建对象所调用的方法  创建对象的收尾工作

便于程序员的开发  创建对象的时候给属性赋值

构造方法的特点：

1. 没有返回类型 连 void都没有
2. 构造方法的名字和类名一致

访问权限限定符 类名 （参数）{赋值}

判断：构造方法只有一个（错误）

构造方法当程序员不进行编写的时候，默认为一个空参构造方法

当程序员编写构造方法的时候，默认空参构造方法就不存在 需要自己写

学习了构造方法可以在引用数据类型数组这样赋值

import java.util.*;
public class Test{
	public static void main(String[] args){
		// 创建一个学生数组-可以存放4个学生信息
		Student[] data = {
			new Student("Jack",20,100,'男'),
			new Student("Anron",22,78,'男'),
			new Student("Amy",19,98,'女'),
			new Student("Tom",23,10,'男')
		};
	}
}
/**
	创建一个学生类 Student 给所有属性赋值
		学生有 name age score gender
*/
class Student{
	private String name;
	private int age;
	private int score;
	private char gender;

	// 构造方法
	public Student(String name, int age, int score, char gender){
		this.name = name;
		this.age = age;
		this.score = score;
		this.gender = gender;
	}

	// getter
	public String getName(){
		return name;
	}
	// setter
	public void setName(String name){
		// "Jack"
		this.name = name;
	}

	public int getAge(){
		return age;
	}

	public void setAge(int age){
		this.age = age;
	}

	public int getScore(){
		return score;
	}

	public void setScore(int score){
		this.score = score;
	}

	public char getGender(){
		return gender;
	}

	public void setGender(char gender){
		this.gender = gender;
	}
}

 构造方法的首行

构造方法的首行有什么？

默认有 super()   在执行本构造方法之前 先去执行父类的构造方法

 具体执行父类的那一个构造方法 看参数

如果父类中没有无参的构造方法

1. 手动的给父类提供无参构造方法
2. 给super(...) 传参

Object java中的 鼻祖类/引用数据类型的父类

一个类没有extends 哪一个类型 默认继承自Object

 简单的例子：

public class TestConstruct{
	public static void main(String[] args){
		Teacher tt=new Teacher("小茗",18,"20211569");
		tt.show();
	}
}
class Person{
	String name;
	int age;
	public Person(String name,int age){
		this.name=name;
		this.age=age;
	}
}

class Teacher extends Person{
	String teaId;
	public Teacher(String name,int age,String teaId){
		super(name,age);//厉害的super()
		this.teaId=teaId;
	}
	public void show(){
		System.out.println(name+age+" "+teaId);
	}
}

 this(xxx);

this. 调用本类的属性方法

this()  执行本构造方法之前 先去执行 本类的其他构造方法

具体执行本类的哪一个方法  看参数

public class Test{
	public static void main(String[] args){
		Student s1=new Student("zhangSan",11);
	}
}

class Person{
	String name;
	int age;

	public Person(){
		System.out.println("This Perosn()");
	}
	public Person(String name,int age){
			System.out.println("This Person(String name,int age)");
	}

}
class Student extends Person{
	public Student(){

		System.out.println("This Student()");
	}
	public Student(String name,int age){
		this();
		System.out.println("This Student(String name,int age)");
	}
}

面试题：构造方法的首行能同时出现 this(xx),super(xxx)吗 不可以

面试题：构造方法可以方法覆盖吗？

构造方法并不能被继承

所以构造方法不能覆盖

面试题：构造方法可以方法重载吗？

可以 满足用户的不同需求

Super. 调用父类的属性/方法

Super() 执行本构造方法之前先去执行父类的构造方法

三.这种情况会变

 此时的x指向的地址和s1的地址一样，x修改的内容是s1指向的内容，所以会输出s1.name为李四

public class TestArgs4{
	public static void main(String[] args){
		Student s1 = new Student("张三");
		change(s1);
		System.out.println(s1.name);
	}
	// x 和 y
	// change() 调用结束 x y k 消亡
	public static void change(Student x){
		x.name = "李四";
	}
}

class Student{
	String name;
	public Student(String name){
		this.name = name;
	}
}

四.Scanner

 使用扫描仪 Scanner时需要导入包 

next()

当出现空格/回车时结束

import java.util.*;
public class TestScanner{
	public static void main(String[] args){
		Scanner sc=new Scanner(System.in);

		String name=sc.next();
		System.out.println(name);
	}
}

nextLine();

nextLine();可以拿走一行的数据 但是会有bug 当next()结束时的回车 nextLine()也拿走了

可以提前写入一个 sc.nextLine() 拿走回车 这样写

 对于next(),有nextInt(),nextByte(),nextLong()...唯独没有nextChar(); 当需要输入的时候可以这样写

String str = sc.next();// "男"/"女"
		 char gender = ' ';
		 char gender;
	
		if(str.equals("男")){
			gender = '男';
		}else{
			gender = '女';
		}
		//char gender = str.equals("男")?'男':'女';

 结合引用类型对象例子：

import java.util.*;
public class Test{
	public static void main(String[] args){
		// 接收用户的输入
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入姓名");
		String name = sc.next();
		System.out.println("请输入电话号码");
		long phone = sc.nextLong();
		System.out.println("请输入密码");
		String password = sc.next();
		System.out.println("请选择性别[A-男 B-女]");
		String choice = sc.next();// "A" | "B"
		char gender = choice.equals("A")?'男':'女';
		System.out.println("请输入余额");
		double salary = sc.nextDouble();
		// 创建对象
		User uu = new User(name, phone, password, gender, salary);
		System.out.println(uu.name);
	}
}

class User{
	String name;
	long phone;
	String password;
	char gender;
	double salary;

	public User(String name, long phone, String password, char gender, double salary){
		this.name = name;
		this.phone = phone;
		this.password = password;
		this.gender = gender;
		this.salary = salary;
	}
}