面向对象语言的基本特征（继承，final关键字，组合，多态，向上转型，向下转型，重写，重写与重载的区别）

Java语言的基本特征

继承

1.定义：就是将共性进行抽取。使用关键字extends来实现继承。
2.语法规则：class 子类 extends 父类
3.java中一个子类只能继承一个父类（单继承）。
4.对于父类的private的字段和方法，子类是无法访问的。
5.引入一个关键字：super（代表父类对象的引用）

• super.data//访问父类的成员变量
• super.func()//访问父类的成员方法
• super()//代表访问父类的成员构造方法

6.子类对象要构造，先要帮助父类对象进行构造，所有的构造对象，都得通过构造方法来构造。

继承的优点：可对代码进行重用。

class Dog extends Animal{

其中："Dog"是子类/派生类。"Animal"是父类/基类/超类

举例：

class Animal{//共性
    public String name;
    public int age;
    public void eat(){
        System.out.println(name+"eat()");
    }
}
class Dog extends Animal{

}
class Bird extends Animal {//特性
    public void fly() {
        System.out.println(name + "fly()");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name = "修勾";
        dog.eat();
    }

    public static void main1(String[] args) {
        Bird bird=new Bird();
        bird.name="修鸟";
        bird.eat();
    }
}

final关键字

final关键字修饰一个变量或者字段的时候, 表示常量 (不能修改).
用于修饰类，属性和方法：

• 被final修饰的类不可以被继承
• 被final修饰的方法不可以被重写
• 被final修饰的变量不可以被改变
  举例：

final public class Animal { 
 ... 
} 
public class Bird extends Animal { 
 ... 
} 
// 编译出错
Error:(3, 27) java: 无法从最终com.bit.Animal进行继承

组合

和继承类似, 组合也是一种表达类之间关系的方式, 也是能够达到代码重用的效果.
举例：

public class Student { 
 ... 
} 
public class Teacher { 
 ... 
} 
public class School { 
 public Student[] students; 
 public Teacher[] teachers; 
} 

组合只是将一个类的实例作为另外一个类的字段，并不涉及特殊的语法。

多态

向上转型

形如下面的代码：

Bird bird = new Bird("小鸟"); 
Animal bird2 = bird; 
// 或者写成下面的方式
Animal bird2 = new Bird("小鸟");

此时 bird2 是一个父类 (Animal) 的引用, 指向一个子类 (Bird) 的实例. 这种写法称为 向上转型
什么时候会发生向上转型？

• 直接赋值

Animal animal=new bird("小鸟"，14)

• 方法传参

public class Test { 
 public static void main(String[] args) { 
 Bird bird = new Bird("小鸟"); 
 feed(bird); 
 } 
 public static void feed(Animal animal) { 
 animal.eat("谷子"); 
 } 
}
//执行结果
小鸟在吃谷子 

• 方法返回

public class Test { 
 public static void main(String[] args) { 
 Animal animal = findMyAnimal(); 
 } 
 public static Animal findMyAnimal() { 
 Bird bird = new Bird("圆圆"); 
 return bird; 
 } 
} 

向下转型

向下转型就是父类对象转成子类对象

 (Bird) 表示强制类型转换
Bird bird = (Bird)animal; 
bird.fly();

的向下转型有时是不太可靠的，为了让向下转型更安全, 我们可以先判定一下看看 animal 本质上是不是一个 Bird 实例, 再来转换

Animal animal = new Cat("小猫"); 
if (animal instanceof Bird) { 
 Bird bird = (Bird)animal; 
 bird.fly(); 
} 

instanceof 可以判定一个引用是否是某个类的实例. 如果是, 则返回 true. 这时再进行向下转型就比较安全了.

重写

子类实现父类的同名方法, 并且参数的类型和个数完全相同, 这种情况称为 覆写/重写/覆盖(Override).
方法重写的条件：

1. 函数名称相同。
2. 函数的参数列表相同（个数，类型）。
3. 函数的返回值相同。
4. 静态方法，private修饰和被final修饰的方法是不可以重写的。
5. 子类的访问权限要大于父类的访问权限。
   举例：

public void eat(){
    System.out.println(name+"eat()");
}
public void eat(){
    System.out.println("Dog:eat()");
}

重载和重写的区别

方法的重载和方法的重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。
重载：

• 方法名称相同，参数类型及个数不同
• 范围是在一个类中。
• 没有权限要求。
  重写：
• 方法名称，返回值类型，参数的类型及个数完全相同。
• 范围只在继承关系中。
• 被覆写的方法不能拥有比父类更严格的访问控制权限。