java学习-day09-面向对象(四)-final关键字、多态、异常

final 关键字

final 可修饰 类、方法、成员变量、局部变量
在 继承 中，子类 可以更改 父类 的功能，当 父类 功能 不允许 子类 修改 时，可以 利用 final 关键字 修饰 父类
特点：
1、被 final 修饰 的 类，不能被 继承
2、被 final 修饰 的 方法，不能 被 重写
3、被 final 修饰 的 变量，值 不能 被 改变
4、常量 定义 形式：final 数据类型 常量名 = 值

public class Test1 {
	public static void main(String[] args) {
		Zi zi = new Zi();
//		zi.age = 20;  // 被 final 修饰 的变量 不能 被 改变 
		System.out.println(zi.age);
		System.out.println(Zi.name);
	}
}
//final class Fu{ //1、被 final 修饰的 类 不能被继承
class Fu{
//	final public void eat() { //2、 被 final 修饰 的成员方法，不能被子类 重写 
	public void eat() {
		System.out.println("父亲在吃肉");
	}
}
class Zi extends Fu{
	// 变量 前 加 个 static 方便 通过类名调用
	static final String name = "java";
	final int age = 10;
	@Override  // 当重写 方法时，加上 @Override 以便区分
	public void eat() {
		System.out.println("儿子在喝汤");
	}
}

多态

多态 是 java 中 重要的特征。表示一个对象有多种形态。
多态 的 特点：
1、 多态 的 前提 是 有 继承关系
2、多态 的产生需要有 方法的 重写
3、父类 引用 指向 子类 对象 。即 向上 造型
4、多态 编译时类型由声明该变量时使用的类型决定 ，运行时类型由实际赋给该变量的对象决定。即 编译 看左边，运行看右边

// 测试 多态
public class Test2{
	public static void main(String[] args) {
		Dog d = new Dog();
		d.study();// 重写 前，使用 的是 父类的，重写后 使用 的是子类的。
		
		Animal a = new Dog(); // 父类 引用 指向 子类 对象 --多态/向上转型
		// 编译看 左边，运行 看 右边. 只能调用 左边 (父类) 的功能
		// 运行 看 右边：运行结果 看 子类 的功能
		a.study();
	}
}
// 1、多态的 前提：继承+重写
class Animal{
	public void study() {
		System.out.println("正在学习");
	}
}
class Dog extends Animal{
	@Override  // 标志着这是在 重写 父类 的 方法
	public void study() {
		System.out.println("汪汪汪");
	}
}

多态 在 使用 时：
1、调用 成员变量 是 父类 的，即不发生 多态
2、调用 成员方法 时，由于多态 所以 使用 的 是 子类 的
3、调用 静态成员 时，哪个调用就返回哪个，即静态资源不发生多态
注：静态资源 不能 实现 方法重写

// 测试 多态 的 使用
public class Test3 {
	public static void main(String[] args) {
		Sharp s = new Circle();
		s.draw(); // 编译 看 左边，用了 父类 提供 的 方法 声明 部分draw()
				  // 运行 看 右边，用了 子类 提供 的 方法体  --多指 方法重写现象
		// 多态 中 成员变量 使用 父类 的 
		System.out.println(s.sum);
		// 多态中 的 静态资源 --谁调用就使用 谁的，s 是父类类型，所以使用父类
		System.out.println(Sharp.name);
		// 静态资源 不能重写
		s.show();// shape..show() 父类的
		Sharp.show();
	}
}
// 多态 的 前提 ： 继承 + 重写
class Sharp{
	int sum = 10;
	static String name = "jack";
	public  void draw() {
		System.out.println("正在画图");
	}	
	public static void show() {
		System.out.println("shape..show()");
	}
}
class Circle extends Sharp{
	int sum = 20;
	static String name = "rose";
	@Override
	public  void draw() {
		System.out.println("正在画圆");
	}
	public static void show() {
		System.out.println("circle..show()");
	}
}

当 在 多态 中，想使用 子类 成员变量时 ，可通过 向下造型 完成 对 子类 成员变量 的 访问。但 这种 方式 不推荐

public class Test4 {
	public static void main(String[] args) {
		Teacher t = new CgbTeacher();
		t.teach();
		
		CgbTeacher ct = new CgbTeacher();
		System.out.println(ct.name);
		
		// 向下转型
		CgbTeacher ct2 = (CgbTeacher)t;
		System.out.println(ct2.name);
	}
}
class Teacher{
	int sum = 10;
	public void teach() {
		System.out.println("正在上课");
	}
}

class CgbTeacher extends Teacher{
	int sum = 20;
	String name = "jack";
	@Override
	public void teach() {
		System.out.println("正在讲基础");
	}
}

异常

用来 封装 错误信息 的对象

异常的继承关系

Throwable 为 顶级父类，Error 为系统错误，通常 无法修复。我们 学习 的异常 为 Exception
程序中 遇到 异常，通常 两种方式处理： 捕获异常 或 向上抛出
捕获异常结构为：
try{
需要捕获可能发生异常 的 代码;
}catch(异常类型 异常名){
处理方式;
}
向上抛出异常结构为：
例如：public static void main(String[] args) throws Exception{}

import java.util.InputMismatchException;
// 测试 异常 
import java.util.Scanner;

public class Test5_Exception {
	public static void main(String[] args) {
//		method(); //暴露异常
//		method2();
		try {
			method3();
		} catch (Exception e) {
			e.printStackTrace();// 通常用来排错
			System.out.println("执行失败");// 项目上线时直接给出的方案
		}
	}
	// 抛出异常：在会出错 的 方法上 添加代码 throws 异常类型
	// 直接抛出 异常Exception 也是体现了多态，因为根本不关系具体的子类类型
	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(异常类型 异常名){给出解决方案}
	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) { // 当 try 里的代码发生ArithmeticException异常时，会被捕获给出方案		
			System.out.println("第二次输入的整数必须是 > 0 的值");
		}catch(InputMismatchException a) { // 当 try 里的代码发生InputMismatchException异常时，会被捕获给出方案
			System.out.println("请输入两次整数");
		}catch(Exception a) { //当 try 里的代码 发生任意异常时，都会被当做父类类型Exception 处理，给出方案
			// Exception 就是多态 的体现，好处是不关心 具体的子类类型，会把子类当做 父类 来处理，写出通用代码	
			System.out.println("请输入正确的数值");
		}
	}
	public static void method() {
		int a = new Scanner(System.in).nextInt();
		int b = new Scanner(System.in).nextInt();
		System.out.println( a / b);
	}	
}