1、多态
概念：Java中出现了多种形态。
具体表现：
1)方法出现了重名现象(方法重载、方法重写)；
2)对象出现了多种形态(转型、抽象类、接口)；
a、方法重载（overload）
特点：同一个类中，出现了方法重名的现象，但是方法的参数列表不同，与返回值类型无关。
b、方法重写（overwrite、Override）
特点：发生在继承关系中，其中子类出现了与父类同名的方法，参数列表与返回值类型和父类一样。访问控制修饰符不能严于父类。
例1：
public class Animal {
//访问控制修饰符
public void eat(){
System.out.println("吃东西~~~");
}
}
public class Cat extends Animal {
//方法重写
public void eat(){
System.out.println("猫吃鱼~~~");
}
}
public static void main(String[] args) {
Cat cat = new Cat();
cat.eat(); //调用的是重写后的方法
}
例2：
//重写toString()方法
@Override
public String toString() {
return "test2 [a=" + a + ", name=" + name + "]";
}
//toString()方法可以使程序员方便查看对象的当前信息
...
System.out.println(t); //直接打印输出对象即可
快速创建：右击–>source–>Generate toString()
方法重载与方法重写区别?
c、转型（很重要！！！！！
上转型：子类–>父类，自动类型转换；
下转型：父类–>子类，强制类型转换；
例1：
//“父类引用子类对象”
Animal cat = new Cat();
cat.eat(); //调用的是重写后的方法
例2：
//针对Animal类，写一些通用的方法
public static void myEat(Animal a){
//让动物吃东西
a.eat();
//如果是猫，则抓老鼠
if(a instanceof Cat){ //如果对象a 的类型 是Cat
//下转型
Cat cat = (Cat)a;
cat.catCatch();
}
//如果是狗，则看门
if(a instanceof Dog){
//下转型
Dog dog = (Dog)a;
dog.dogDoor();
}
}
public static void main(String[] args) {
Cat cat = new Cat();
Dog dog = new Dog();
myEat(cat); //上转型
myEat(dog);
}
**
也就是说子类可以任意调用父类继承来的方法！！
**
d、final关键字
作用：禁止重写，常量，终止类。
例： //子类就无法重写该方法了
public final void eat(){
System.out.println("吃东西~~~");
}
总结：final修饰的成员变量为常量，其值无法再修改；final修饰的方法，不能被重写；final修饰的类不能被继承。
e、static关键字
场景：往往一些方法比较孤立，不用存储其数据，只是调用该方法一次获得返回值即结束，此时无需创建该类的对象。
一句话：静态方法可以通过 类名.方法名 的形式直接调用。
例1：
public class StaticTest1 {
public static int myAdd1(int a, int b){
return a + b;
}
}
public static void main(String[] args) {
//调用静态方法
int a = 3;
int b = 4;
int c = StaticTest1.myAdd1(a, b);
}
特点：使用时直接“类名.静态方法()”,不用创建其对象。静态方法也叫类方法。静态方法中不能直接调用非静态方法。
例2：
public class Animal {
//static修饰的成员变量叫类变量，属于该类所有对象共有，相当于全局变量。
static int total=0;
public Animal(){
}
}
public static void main(String[] args) {
//可以借助类变量来统计对象的个数
Animal a1 = new Animal();
a1.total = 4;
Animal a2 = new Animal();
System.out.println(a2.total);
a2.total = 6;
Animal a3 = new Animal();
}
特点：类变量属于该类的所有对象共享，相当于全局变量。
例3：
public class Test6 {
static int a;
static String name;
//静态代码块:初始化静态变量
static{
a = 1;
name = "zhangsan";
}
public void function1(){
}
}
特点：其在构造方法前执行，只加载一次。
注意：static关键字只能放在方法、成员变量、代码块前，不能放到class前。static方法中不能出现this。
2、抽象类
抽象类：有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类。
注意：用abstract关键字来修饰这个类。即用abstract关键字修饰的类称为抽象类（即抽象类中可以没有抽象方法）。但是包含抽象方法的类一定是抽象类。抽象类中可以有普通的成员或方法。抽象类不能被实例化。
抽象方法：用abstract关键字来修饰方法时，这个方法为抽象方法。
注意：抽象方法只有方法声明部分，而没有方法体。
例：
public abstract class Shape {
public abstract double getArea();
}
public class Circle extends Shape {
//属性
int r; //半径
@Override
public double getArea() {
return Math.PI *r *r; //Math.PI 用来表示精确的PI
}
}
作用：抽象类是用来被继承的，其子类必须重写父类中的抽象方法，即实现方法体。除非子类也是抽象类。
注意：abstract关键字不能修饰属性和构造方法，不能与static、private、final同时出现。
抽象类与一般类的区别？
3、接口
Java中无法实现多继承（一个子类无法继承多个父类），接口就可以解决多继承问题。
语法：
[修饰符] interface 接口名{
常量;
抽象方法();
}
特点：接口中的方法都是public abstract方法；接口中的变量都是public static final类型的变量。
场景：在工程中，一般是设计阶段后期，会将程序中的所有接口和抽象类都定义出来，以方便后期进行开发阶段的分工。
作用：接口主要用来定义规范。
例1：
public class V {
//属性
double zaizhong; //载重
//方法
public void run(){
System.out.println("行驶");
}
}
public class A {
//属性
String name;
//行为
public void eat(){
System.out.println("吃东西");
}
}
public interface Fly {
//接口中声明的方法都是public abstract方法
void fly();
}
public class Plane extends V implements Fly{
//属性
int flyNumber; //翅膀
//方法。飞行
@Override
public void fly() {
System.out.println("飞机飞行");
}
}
public class Bird extends A implements Fly {
//属性
String color;
//行为：飞行
@Override
public void fly() {
System.out.println("飞行");
}
}
抽象类和接口的区别？
例2：
//一个类只能继承一个父类，但是可以实现多个接口
public class Duck extends A implements Fly,Swim {
@Override
public void swim() {
}
@Override
public void fly() {
}
}
例3：
//接口的继承，接口可以多继承
public interface LiangQi extends Swim,Fly {
void run();
}