※02、继承的概念、方法重写的概念

※继承

子类继承父类，目的子类扩展父类的属性以及方法，就是为了实现代码的复用（继承在Java中只能单继承，不能多继承）

--子类可以继承父类中有 权限访问的属性以及方法

--所有的引用类型都默认继承了超类Object

--继承的概念

/**
 * @author Lantzrung
 * @date 2022年7月23日
 * @Description
 */


// 如果多个类是相似，但是没有做优化处理，当后期维护更新，则修改修改所有代码
// 继承是类与类之间的关系  可以理解为is a
// Student is a Person
public class Person {
	String name;
	String sex;
	int age;

	void eat() {
		System.out.println("普通的吃饭行为！");
	}
	void sleep() {
		System.out.println("普通的睡觉行为！");
	}
}
 class Student extends Person{
/*
* 当学生类和人类类的是相似时，可以使用继承来进行操作
* String name; String sex; int age;
* void eat() { System.out.println("普通的吃饭行为！"); } void sleep() {
* System.out.println("普通的睡觉行为！"); }
*/
//操作一:
// 子类会继承父类的东西【属性、方法】
public void test() {
	System.out.println(name);
	System.out.println(sex);
	System.out.println(age);
	eat();
	sleep();
    }
}

--继承的注意事项

/**
 * @author Lantzrung
 * @date 2022年7月23日
 * @Description
 */

public class Person {
	//操作一:
	//私有化一个属性;
	private String name;
	String sex;
	int age;
 }
 // Student去扩展、继承
class Student extends Person {
	public void test() {
		// 操作一:
		// 这个人类里面类的名字不可见
		// The field Person.name is not visible
		// System.out.println(name);

		// 操作二:
		// 输出一个hascode的方法，并查看源码，发现hashcode()方法在Object类型里面
		System.out.println(hashCode());
	}
	// 细节:
	// 1、私有化属性和方法不能继承的，非私有化的看权限【default需要查看是否在同一个包内、protected可以、public可以】
	// 2、继承中只有单继承，没有多继承，所有的引用类型的超父类为Object
	// 3、继承链的概念:Student-->Person-->Object

}

※方法的重写（两同、一大、两小）

子类重写父类的方法（子类覆盖父类的方法），凸显出子类的行为特征

--方法名相同、方法参数列表相同

--和方法修饰符、返回值类型有关

--子类重写父类的方法，子类方法的权限修饰符比父类的大或者相等

--子类重写父类的方法，子类的返回值类型比父类的小或者相等【引用类型】【基本数据类型要一致或者类型提升兼容】

--子类重写父类的方法，子类的抛出的异常类型要比父类的小或者相等

--当子类中有和父类一样的私有化方法，那么子类的私有化方法是一个普通方法，并不是重写了父类的方法

/**
 * @author Lantzrung
 * @date 2022年7月23日
 * @Description
 */

public class Person{
	
	public int demo() {
		return 1;
	}
	
	public Person demo1() {
		return new Person();
	}
	
	// 引用类型
	public String demo2() {
		return "";
	}
	
	public Person demo3() throws NullPointerException {
		return new Person();
	}
	
	private void demo5() {
		
	}
	
    void eat() {
		System.out.println("人吃饭的行为");
  }

}
class Student extends Person {
//	// 两同
//	// 操作一:
//	// 子类要和父类的方法名相同
//	@Override
//	public void eat1() {
  报错: The method eat1() of type Student must override or implement a supertype method
//		System.out.println("学生在饭堂吃饭");
//	}
//
//	// 操作二:
//	// 子类的方法参数列表和父类的方法参数列表要一致
//	@Override
//	public void eat(String name) {
      报错:The method eat(String) of type Student must override or implement a supertype method
//		System.out.println("学生在饭堂吃饭");
//	}
//
//	// 一大
//	// 操作一:
//	// 因为子类的权限修饰符要比父类的大
//	private void eat() {
//		System.out.println("学生在饭堂吃饭");
//	}
//
//	// 而现在父类使用的修饰符是default 子类使用的是private 权限修饰符比它要小一个级别
//
//	// 操作二:
//	// 但要是我使用public 和 protected的时候就可以了，因为比它大一个级别和两个级别
//	// 所以子类的权限修饰符要比父类的权限修饰符要大
//	@Override
//	protected void eat() {
//		System.out.println("学生在饭堂吃饭");
//	}
//
//	@Override
//	public void eat() {
//		System.out.println("学生在饭堂吃饭");
//	}
//
//	// 一小:
//	// 基本数据类型--类型提升 【基本数据类型要一致或者类型提升兼容】
//	// 操作一:
//	public int demo() {
//		return 1;
//	}
//
//	// 操作二:
//	// 编译运行成功 因为子类的基本数据类型都比父类的数据类型相等或者小于它
//	public int demo() {
//		int item = 1;
//		return item;
//	}
//
//	public int demo() {
//		short item = 1;
//		return item;
//	}
//
//	// 操作三:
//	// long类型比int类型大
//	public int demo() {
  报错:Type mismatch: cannot convert from long to int
//		long item = 1;
//		return item;
//	}
//
	
//	--子类重写父类的方法，子类的返回值类型比父类的小或者相等
	// 操作一:
//	public Person demo1() {
//		return new Person();
//	}

	// 操作二:
//	public Student demo1() {
//		return new Student();
//	}
	
	
//	// 引用类型 【引用类型，前提是要有继承链，子类的返回值类型比父类的小或者相等】
//	// 操作一: 
//	public String demo2() {
//		return "";
//	}
//
//	// 操作二:
  报错:The return type is incompatible with Person.demo1()	
  原因:Person类不是String类里的，也没有产生继承链
//	public Person demo2() {
//		return new Person();
//	}
	

//	// 操作三:
  报错:The return type is incompatible with Person.demo1()
  原因:	Student类不是String类里的，也没有产生继承链
//	public Student demo2() {
//		return new Student();
//	}
//	
	
	// --子类重写父类的方法，子类的抛出的异常类型要比父类的小或者相等
	// 操作一:  
//	public Person demo3() throws NullPointerException {
//		return new Person();
//	}
	
	// 操作二: 
	// 报错:Exception Exception is not compatible with throws clause in Person.demo3()
    // 这里重写的方法的异常比父类的大，不兼容，所以报错
//	public Person demo3() throws Exception {
//		return new Person();
//	}
	
	// --当子类中有和父类一样的私有化方法，那么子类的私有化方法是一个普通方法，并不是重写了父类的方法
	// 操作一:
	// 这里相当于重写在子类里面定义一个新的方法【并不是方法重写】
//	private void demo5() {
//
//	}
	
	// 操作二:
	// 加上重写注解
	// 报错:The method demo5() of type Student must override or implement a supertype method
	// 原因是因为父类中私有化了方法，子类中无法重写父类的私有化方法
//	@Override
//	private void demo5() {
	
//	}

}

-- 方法重写练习：

《一》 --定义一个动物类Animal

--属性name、sex

--定义eat方法（）

《二》定义一个鸟类Bird，继承动物类的属性，子类重写父类的eat方法，定义一个移动move【飞行】的方法

《三》在鸟类中定义一个移动方法move（）

--定义一个鸵鸟类ostrich 继承鸟类 ，重写鸟类的移动move【奔跑】方法

/**
 * @author Lantzrung
 * @date 2022年7月24日
 * @Description
 */


public class Animal {

	// 测试
	public static void main(String[] args) {
		Animal a = new Animal("动物", "未知");
		a.eat();// 动物在进食... 性别:未知

		Bird b = new Bird("小鸟", "公");
		b.eat();// 小鸟在进食... 性别:公
		b.move();// 小鸟通过飞行进行移动...
		Ostrich o = new Ostrich("鸵鸟", "母");
		o.eat();// 鸵鸟在进食... 性别:母
		o.move();// 鸵鸟通过飞行进行移动...

	}

	String name;
	String sex;

	public Animal(String name, String sex) {
		super();
		this.name = name;
		this.sex = sex;
	}

	public void move() {
	}

	public void eat() {
		System.out.printf("%s在进食... 性别:%s\n", name, sex);
	}
}

class Bird extends Animal {
	public Bird(String name, String sex) {
		super(name, sex);

	}

	@Override
	public void eat() {
		System.out.printf("%s在进食... 性别:%s\n", name, sex);
	}

	public void move() {
		System.out.printf("%s通过飞行进行移动...\n", name);
	}
}

class Ostrich extends Bird {
	public Ostrich(String name, String sex) {
		super(name, sex);
	}

	@Override
	public void eat() {
		System.out.printf("%s在进食... 性别:%s\n", name, sex);
	}

	@Override
	public void move() {
		System.out.printf("%s通过飞行进行移动...\n", name);
	}
}