2021-04-13

一,多态
–1，测试
package cn.tedu.oop;
//测试 多态
public class Test1 {
public static void main(String[] args) {
//TODO 创建子类对象–可以用父类的，也可以用自己扩展的，还可以改
Dog d = new Dog();
d.eat();
//TODO 创建多态对象-- 口诀1：父类引用 指向 子类对象–只能用父类的功能
Animal a = new Dog();//通用性/统一调用标准
//口诀2:编译看左边，运行看右边(针对方法)
//调用父类的eat()–统一调用标准，向父类看齐
a.eat();//调用父类的方法声明,使用了子类的方法体
System.out.println( a.age );//调用父类的
// System.out.println( a.name);//多态对象不支持用子类的 name
}
}
//1,创建父类–提取子类的所有共性代码，提高了复用性
class Animal{
int age = 10;
public void eat() {
System.out.println(“啥都吃”);
}
}
//2,创建子类–可以使用父类的功能，减少了子类的代码量
class Dog extends Animal{
String name = “jack”;
//3，什么时候需要重写？–当子类想要改父类原来的功能时
public void eat() {
System.out.println(“狗吃s”);
}
}

二,多态的使用
–1,测试
package cn.tedu.oop;
//测试 多态的使用
//总结:
//1,哪些资源不能被继承? – private / 构造方法
//2,哪些资源不能被重写? – static / final
//3,多态怎么统一的调用标准? – 只能调用父类的
//4,怎么使用子类特有的? – 多态对象不支持,只能new一个子类的对象
//5,多态有什么好处? – 增强程序的通用性 / 统一标准
//多态根本不关心具体的子类类型,屏蔽掉了子类之间的不同,把子类当父类来看
public class Test2 {
public static void main(String[] args) {
//口诀1：父类引用 指向 子类对象
Fu f = new Zi();
//口诀2：编译看左边(只能调用父类的)
//运行看右边(如果方法被重写了,执行子类的方法体)
System.out.println(f.age);//1,使用了父类的10
f.eat();//2,重写了，使用了父类的方法声明 ，使用了子类的方法体
f.sleep();//3,没重写，使用了父类的方法声明 和 方法体
// f.show();//多态对象不能用子类扩展的
f.game();//4,使用了父类的
Fu.game();
}
}
//静态资源
class Fu{
int age = 10;
static public void game() {
System.out.println(1);
}
public void eat() {
System.out.println(1);
}
public void sleep() {
System.out.println(2);
}
}
class Zi extends Fu{
int age = 20;
static public void game() {
System.out.println(2);
}
@Override
public void eat() {
System.out.println(100);
}
public void show() {
System.out.println(200);
}
}
三,异常
–1，测试
package cn.tedu.oop;

	import java.util.InputMismatchException;
	import java.util.Scanner;

	//测试 异常
	public class Test3 {
		public static void main(String[] args) {
	//		method();//暴露异常
	//		method2();//捕获异常
			try {
				method3();//抛出异常
			}catch(Exception e) {
				System.out.println("执行错误。。");
			}
		}
		//抛出异常:交给调用者处理
		/*
		 * 直接在方法声明后添加: throws 异常类型
		 */
		public static void method3() throws Exception {//多态
			int a = new Scanner(System.in).nextInt();
			int b = new Scanner(System.in).nextInt();
			System.out.println(a/b);
		}
		//捕获异常:自己的问题自己处理,调用者很安全
		/*
		 * try{
		 *     有问题的代码
		 * }catch(异常类型1 异常名){
		 * 		给出的解决方案1
		 * }catch(异常类型2 异常名){
		 * 		给出的解决方案2
		 * }
		 */
		public static void method2() {
			try {
				int a = new Scanner(System.in).nextInt();
				int b = new Scanner(System.in).nextInt();
				System.out.println(a/b);
			}catch(ArithmeticException a) {
				System.out.println("第二次输入不能为0 !");
			}catch(InputMismatchException a) {
				System.out.println("请输入两次整数 !");
			}catch(Exception a) {//多态
				System.out.println("请输入正确的数据 !");
			}
			//接下来不知道还要几个异常,不知道叫啥,通用的解决方案--多态
			//不关心具体的子类类型,把子类当做父类看.写出通用的代码
		}
		//暴露异常
		public static void method() {
			//1，接受用户输入的两个整数
			int a = new Scanner(System.in).nextInt();
			int b = new Scanner(System.in).nextInt();
			//2，做除法运算
			System.out.println(a/b);
		}
	}

四,抽象类
–1,概述
Java中可以定义没有方法体的方法，该方法由其子类来具体的实现。该没有方法 体的方法我们称之为抽象方法，含有抽象方法的类我们称之为抽象类。
抽象类可以理解为是一个只有方法声明没有方法体的特殊类。
–2,测试
package cn.tedu.oop;
//测试 抽象类
public class Test4 {
public static void main(String[] args) {
//TODO 第三步，创建多态对象测试
// Fu2 f = new Zi2();//1,抽象类不可以被实例化
Fu2 f = new Zi3();//父类引用 指向 子类对象
//编译看左边(只能用父类的),运行看右边(方法重写后用子类的方法体)
f.eat();
f.game();
}
}
//第一步，创建父类–设计成抽象类
abstract class Fu2{
//3,抽象类是一个特殊的类?–因为抽象类里可以包含抽象方法和普通方法
//2,如果一个类里包含着抽象方法,那么,这个类必须设计成抽象类
//1,抽象方法:没有方法体,被abstract修饰
abstract public void eat() ;
abstract public void game() ;
}
//第二步，创建子类–继承抽象类
class Zi3 extends Fu2{
//2,子类继承了 抽象的父类,需要重写 所有的抽象方法
@Override
public void eat() {
System.out.println(1);
}
@Override
public void game() {
System.out.println(2);
}
}
abstract class Zi2 extends Fu2{
//1,子类继承了 抽象的父类,会把抽象方法继承过来,此时,
//子类包含着继承来的抽象方法,必须定义一个抽象的子类
}
五,抽象类的使用
–1，测试
package cn.tedu.oop;
//测试 抽象类的使用
public class Test5 {
public static void main(String[] args) {
Fu3 f = new Zi4();
f.name = “rose”;//修改了变量的值
System.out.println( f.name );//打印了变量的值

	//		Fu3.AGE = 20;//常量的值不能改
			System.out.println( Fu3.AGE );//打印了常量的值
		}
	}
	abstract class Fu3{
		//1,抽象类 里有构造方法吗?--有，不是为了自己new,而是为了子类new
		public Fu3() {
			System.out.println("这是 父类 的 构造方法，用来new");
		}
		//2,抽象类 里有成员变量吗?--有，有常量吗?--
		String name = "jack";
		public static final int AGE = 10;//常量的标准写法
	//	final int age = 10;//常量的简写
		//3,抽象类 里有普通方法？抽象方法？
		abstract public void eat1();//没有方法体的方法
		abstract public void eat2();//没有方法体的方法
		public void eat3() {//普通方法，有方法体的方法
			System.out.println(3);
		}
	}
	//4,子类继承了抽象的父类后，需要重写所有 抽象方法，否则，是一个抽象类
	//5，继承来的普通方法，必须重写吗？--想改才重写
	class Zi4 extends Fu3{
		public Zi4() {
			super();//自动调用父类的 无参 构造方法
			System.out.println("这是 子类 的 构造方法，用来new");
		}
		@Override
		public void eat1() {
			System.out.println(1);
		}
		@Override
		public void eat2() {
			System.out.println(2);
		}
	}