一.多态
1.定义:多态指同一个实体同时具有多种形式。它是面向对象程序设计（OOP）的一个重要特征。主要是指同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。好处是可以把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，统一调用标准。例如：水，在不同时刻可以有多种形态，包括水蒸气，冰，水。
2.特点:
1.多态的前提是继承。
2.要有方法的重写。
3.父类引用指向子类对象,如：Animal a = new Dog(); – 小到大，向上转型。
4.多态中，编译看左边，运行看右边。
3.简单案例
package Practice;
public class Practice_04 {
public static void main(String[] args) {
Animal a = new Dog();//父类引用指向子类对象。
//编译看左边，运行看右边。
a.eat();
// Dog dog = new Dog(); ctrl + 1 可以便捷生成左侧代码。
}
}
class Animal{
public void eat() {
System.out.println("吃肉");
}
}
class Dog extends Animal{
@Override
public void eat() {
System.out.println("吃狗粮");
}
}
4.优点:
<1>多态可以让我们不用关心某个对象到底是什么具体类型，就可以使用该对象的某些方法。
<2>提高了程序的扩展性和可维护性。
5.特点:
<1>成员变量：使用的是父类的。
<2>成员方法：由于存在重写现象所以使用的是子类的。
<3>静态成员：随着对象而存在，谁调用的就返回谁的。
6.简单案例
package Practice;
public class Practice_05 {
public static void main(String[] args) {
Father f = new Son();
f.read();//成员方法使用的是子类的。
System.out.println(f.age);//成员变量使用的是父类的。
System.out.println(Son.name);//调用Son的静态成员变量。
System.out.println(Father.age);//调用Father的静态成员变量。
Father.read();//静态资源不存在重写现象。
}
}
class Father{
String name;
static int age = 99;
static public void read() {
System.out.println("看报纸");
}
}
class Son extends Father{
static String name = "Angle";
int age;
static public void read() {
System.out.println("看漫画");
}
}
二.异常
1.定义:用来封装错误信息的对象。
2.组成结构:类型，提示，行号。
3.继承结构:
Throwable - 顶级父类
– Error：系统错误，无法修复，一般不是软件问题
– Exception：可修复的错误
–RunTimeException
–ClassCastException
–ClassNotFoundException
4.简单案例
package Practice;
import java.util.Scanner;
//测试异常。
public class Practice_01 {
public static void main(String[] args) {
Method();
}
public static void Method() {
//接收用户输入的两个整数，做除法运算。
System.out.print("请输入第一个数a:");
int a = new Scanner(System.in).nextInt();
System.out.print("请输入第二个数b:");
int b = new Scanner(System.in).nextInt();
System.out.println(a/b);
}
}
三.异常处理方案
1.捕获方式:
try{
需要捕获的代码
}catch(异常类型 异常名){
处理方案
}
2.捕获异常中的多态运用
3.抛出方式:
在会发生异常的方法上添加代码：throws 异常类型。
例如: public static void main(String[] args) throws Exception{
四.抽象类
1.定义:Java中可以定义没有方法体的方法，该方法由其子类来具体的实现。该没有方法体的方法我们称之为抽象方法，含有抽象方法的类我们称之为抽象类。抽象类可以理解为是一个只有方法声明没有方法体的特殊类。
2.特点:
<1>通过java关键字abstract实现。
<2>可以修饰方法或者类。
<3>抽象类中可以没有抽象方法（由子类去实现）。
<4>如果类中有抽象方法，那该类必须定义为一个抽象类。
<5>子类继承了抽象类以后，要么还是一个抽象类，要么就把所有抽象方法都重写。
<6> 多用于多态中。
<7>抽象类不可以被实例化。
3.简单案例
package Practice;
public class Practice_04 {
public static void main(String[] args) {
Animal1 an = new Dog1();//抽象类不能实例化，因此new一个非抽象子类。
an.eat();//调用父类的方法声明，若经过重写，则用子类的方法体。
}
}
abstract class Animal1{
public abstract void eat();//抽象方法。
public void sleep() {
//普通方法。
System.out.println("睡");
}
}
class Dog1 extends Animal1{
//要么继承之后重写父类的方法。
public void eat() {
System.out.println("吃狗粮");
}
}
abstract class Cat1 extends Animal1{
//要么还是一个抽象类。
}
4.简单用法
package Practice;
//抽象类的用法。
public class Practice_05 {
public static void main(String[] args) {
Father f = new Son();
System.out.println(f.name);
System.out.println(f.age);
f.read();
f.eat();
}
}
abstract class Father{
//构造方法，为了创建对象。
//既然抽象类不能被new，那么创建构造方法的目的是为了给子类new。
public Father() {
System.out.println("无参构造方法");
}
public void read() {
System.out.println("看新闻");
}
public abstract void eat();
int age = 20;
public static final String name = "ydx";
}
class Son extends Father{
public Son() {
super();
}
public void eat() {
System.out.println("吃饭");
}
}