B站宋红康JAVA基础视频教程个人笔记chapter06（面向对象进阶）

1. 关键字this的使用

1.1 为什么需要用this

当使用getter和setter的时候，形参名和属性名一样，如何区别？
答案：this.后面的是属性，没有this.的叫做形参（this指的是当前对象，谁调用就是谁）

public class Person{
	private int age;
	public void setAge(int age) {
		this.age = age
		// 前面一个age是属性，后面这个age属于形参
	}
}

1.2 this调用构造器

使用"this(形参列表)"格式，调用当前类指定构造器
可以在类中的构造器，调用当前类中的其他构造器
要求："this(参数列表)"必须声明在构造器中的首行
结论："this(参数列表)"在构造器中最多声明一个

public class Person{
	int age;
	String name;
	
	public Person(){
	}
	
	public Person(int age){
		this(); // 调用无参构造器（第一个）
		this.age=age;
	}
	
	public Person(int age, String name){
		this(age); //调用第二个构造器
		this.name=name;
	}
}

2.继承性的学习

2.1 为什么需要继承性

1.有助于减少代码的冗余，提高代码复用性
2.利于功能的扩展
3.让类和类之间产生’is-a’的关系，为多态的使用提供了前提
4.子类可以直接继承父类的属性和方法
5.父类使用private定义属性后，子类不能直接访问该属性（封装性）

2.2 继承的格式

class A {
	// 属性，方法
}

class B extends A {
	// 这里可以直接继承使用A的方法和属性
}

class C extends B {
	// 这里体现了继承可以有多层
	// 支持单继承，一个子类只有一个父类
}

类A：父类，superClass，超类，基类
类B：子类，subClass，派生类

2.3 java中继承性的缺点

单继承性:后续需要通过类实现接口的方式，解决单继承性的局限

2.4 子类中方法的重写

2.3.1为什么需要重写？

父类的方法可能不适合子类，需要对父类的方法进行覆盖和重写的操作

2.3.2

注意点
1.子类的权限修饰符要大于父类的权限修饰符
2.子类不能重写父类权限修饰符为private的方法
3.父类返回值是void,子类就必须是void
4.父类返回是基本数据类型，子类必须一致
5.父类被重写的方法返回值类型是引用数据类型，那么子类的返回值可以和父类的返回值相同，或者是父类返回值的子类
6.子类抛出的异常类型可以和父类被重写方法抛出的异常类型相同，或者父类抛出异常类型的子类

3. 关键字super的学习

3.1 为什么需要super()

举例1：子类继承父类以后，对父类的方法进行重写，那么子类是否可以对父类被重写的方法进行调用?

1.super的理解：父类的
2.super可以调用的结构：属性，方法，构造器
3.子类调用父类被重写的方法：super.eat()这样就能访问（super.属性/方法）
4.子类的构造器默认会通过super()调用父类的空参构造器
5.构造器中的this()和super不能同时使用
6.子类一定会调用父类的构造器，要么是空参构造器（隐式调用），要么是子类构造器中调用父类重载后的构造器
7.super(参数列表) 表示调用父类的构造器

构造器调用举例

class Person {
	String name;
	int age;
	// 这里提供了带参构造器，就不会自动创建空参构造器了
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
}

class Student extends Person {
	public Student(String name, int age) {
		super(name, age); // 这里会调用父类的构造器
	}
}

4. 子类为什么会有父类的属性和方法

在通过子类的构造器创建对象时，子类的构造器会直接或间接调用到父类的构造器，而父类的构造器也会如此…直到调用到Object类中的构造器为止
正因为调用过父类的构造器，所以我们将父类的所有属性方法调用到了内存中，供子类的对象使用

5. 多态性的学习

1.java中多态性的体现

声明的是一个父类类型，new的时候是一个子类的类型
子类对象的多态性：父类的引用指向子类的对象
例如：Person p1 = new Man();
p1.eat()如果父类和子类都有这个eat(0方法，默认会调用子类的eat方法

多态的场景下：调用方法：

编译时：认为方法是声明左边父类类型的方法
执行时：实际执行的是子类重写父类的方法
编译看左边，运行看右边

2.多态性的使用前提：

1.要有类的继承关系
2.要有方法的重写

3.多态的适用性：

适用于方法，不适用于属性

4.举例

public class AnimalTest{
	public static void main(String[] args){
		AnimalTest test = new AnimalTest()
		test.adopt(new Dog()); //这里出现了多态，可以调用狗的方法 // 答应狗吃饭和睡觉的逻辑
	}
	public void adopt(Animal animal){
		animal.eat();
		animal.sleep();
	}
}

public class Animal{
	public void eat(){

	}
	public void sleep() {

	}	
}

public Dog extends Animal{
	public void eat(){

	}
	public void sleep() {

	}	
	public void watchHome(){

	}
}

public Cat extends Animal{
	public void eat(){

	}
	public void sleep() {

	}	
	public void mouse(){
		
	}
}

好处：极大的减少了代码的、冗余，无需定义多个重载的方法
缺点：创建了子类的对象，也加载了子类特有的属性和方法，但是由于声明为父类的引用，导致无法直接调用子类特有的方法和属性

属性的调用看左边就行，属性不存在多态性

6. Object类方法的学习

6.1 Object类中的equals()方法的学习

6.1适用性

任何引用数据类型都可以使用

6.2java.lang.Object类中equals()的定义

public boolean equals(Object obj) {
	return (this == obj)
}

6.3 子类使用说明

自定义的类中没有重写Object中的equals(）方法的情况下，调用的就是Obejct中的equals方法，比较的是两个对象的地址值是否相同

对于String,File,Date和包装类都自动重写了Object中的equals方法，比较的具体的实体内容是否相同

开发中自定义的类比较实体内容就需要重写equals方法,如下，假设自定义了一个User类

public boolean equals(Object obj){
	if (this == obj) {
		return true;
	}
	if (obj instanceof User){
		User user = (User)obj;
		if(this.age==user.age && this.name.equals(user.name)){ // 这里name是String类型自动实现了equals
			return true;
		} else{
			return false;
		}
	}
}

IDEA中也有快捷键实现重写equals()，可以自动生成

6.2 Object中toString()方法的使用

6.1Object类中toString(）的定义

public String toSting(){
	return getClass().getName() + "@" + Integer.toHexString(hashCode())
}

6.2开发中使用场景

平时在调用System.out.println()打印对象引用变量时候，其实就调用了对象的toString()
像String,File,Date或包装类等Object的子类，他们都重写了Object()类的toString(）方法，返回当前对象的实体内容

public String toString(){
	return "User{"+"name='"+name+'\''+",age="+age+'}'
}