一、继承
java
class Subclass extends Parentclass{
field;//属性
method;//方法
}1.访问成员变量与方法
java
public class Base {
public int a = 1;
public int b = 2;
}
class Derived extends Base{
public int a = 11;
public int c = 3;
public void test(){
System.out.println(super.a);
System.out.println(this.a);
System.out.println(this.b);
System.out.println(this.c);
}
}
class Test {
public static void main(String[] args) {
Derived derived = new Derived();
derived.test();
}
}以上代码输出结果为1 11 2 3，要搞清楚其中的意思，我们需要知道super关键字与this关键字的区别
|----------------|--------------------|
| this | super |
| this.data | super.data |
| this.func | super.func |
| this()访问其他构造方法 | super(a,b)访问父类构造方法 |
| 不能在静态方法中使用 ||
在this中父类与子类都有相同属性时，优先访问子类（就近原则）；
访问不同属性时，优先父类，父类有访问父类，无则访问子类；子类有访问子类，子类无则报错。
2.重写
把父类方法在子类中重新实现，方法里的内容可以不同。
特点：方法名相同，参数列表相同，返回值相同。
java
public class Animal {
public String name;
public int age;
public void shout(){
System.out.println("发出动物叫声....");
}
}
class Dog extends Animal{
@Override
public void shout() {
System.out.println("汪汪汪....");
}
}
class Cat extends Animal{
@Override
public void shout() {
System.out.println("喵喵喵....");
}
}
class Test {
public static void main(String[] args) {
Dog dog = new Dog();
dog.shout();
Cat cat = new Cat();
cat.shout();
}
3.子类构造方法
构造子类构造方法前一定要完成父类对象的构造，通过super调用父类构造方法。
java
public class Animal {
public String name;
public int age;
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
}
class Dog extends Animal{
public Dog(String name, int age) {
super(name, age);
}
}4.在继承中的静态代码块与实例代码块
java
public class Animal {
public String name;
public int age;
static{
System.out.println("父类静态代码块执行中....");
}
{
System.out.println("父类实例代码块执行中....");
}
public Animal(String name, int age) {
this.name = name;
this.age = age;
System.out.println("父类构造方法执行中....");
}
}
class Dog extends Animal{
static {
System.out.println("子类静态代码块执行中....");
}
{
System.out.println("子类实例代码块执行中....");
}
public Dog(String name, int age) {
super(name, age);
System.out.println("子类构造方法执行中....");
}
}
class Test {
public static void main(String[] args) {
Dog dog = new Dog("旺财",3);
}
5.final
被final修饰，证明当前类不能被继承。
二、多态
在了解多态前，我们需要了解向上转型
1.向上转型
1.1直接赋值（父类引用引用子类对象）
java
public class Animal {
public String name;
public int age;
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public void shout(){
System.out.println("发出动物叫声....");
}
}
class Dog extends Animal{
public Dog(String name, int age) {
super(name, age);
}
@Override
public void shout() {
System.out.println(this.name+"汪汪汪....");
}
}
class Test {
public static void main(String[] args) {
Animal animal = new Dog("wangcai",2);
}1.2利用参数传递
java
public class Animal {
public String name;
public int age;
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public void shout(){
System.out.println("发出动物叫声....");
}
}
class Dog extends Animal{
public Dog(String name, int age) {
super(name, age);
}
@Override
public void shout() {
System.out.println(this.name+"汪汪汪....");
}
}
class Test {
public static void test1(Animal animal){
}
public static void main(String[] args) {
Dog dog =new Dog("xiaogou",3);
test1(dog);
}1.3返回值传递
java
public class Animal {
public String name;
public int age;
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public void shout(){
System.out.println("发出动物叫声....");
}
}
class Dog extends Animal{
public Dog(String name, int age) {
super(name, age);
}
@Override
public void shout() {
System.out.println(this.name+"汪汪汪....");
}
}
class Test {
public static Animal test2(){
return new Dog("dog",3);
}
}2.动态绑定
java
public class Animal {
public String name;
public int age;
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public void shout(){
System.out.println("发出动物叫声....");
}
}
class Dog extends Animal{
public Dog(String name, int age) {
super(name, age);
}
@Override
public void shout() {
System.out.println(this.name+"汪汪汪....");
}
}
class Test {
public static void main(String[] args) {
Animal animal =new Dog("wangcai",3);
animal.shout();
}当anima（父类）这个引用引用dog对象（子类）后，通过animal这个引用调用自己的成员时，当子类重写了父类的方法，这时调用的是子类的重写方法，这就是动态绑定。
动态绑定的条件：
1.父类引用必须引用子类对象
2.子类重写父类方法
注意：父类被static/final修饰，子类不可重写；父类被private修饰也不行；子类重写父类方法时，子类的访问权限要比父类大。
3.向下转型
向下转型不能直接将父类引用引用子类对象，这里使用强制类型转换，将父类强制转换为子类的类型。
java
public class Animal {
public String name;
public int age;
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public void shout(){
System.out.println("发出动物叫声....");
}
}
class Dog extends Animal{
public Dog(String name, int age) {
super(name, age);
}
@Override
public void shout() {
System.out.println(this.name+"汪汪汪....");
}
}
class Test {
public static void main(String[] args) {
Animal animal = new Dog("wangcai",2);
Dog dog = (Dog) animal;
}但是向下转型不安全，我们通常使用instanceof关键字检查
java
public class Animal {
public String name;
public int age;
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public void shout(){
System.out.println("发出动物叫声....");
}
}
class Dog extends Animal{
public Dog(String name, int age) {
super(name, age);
}
@Override
public void shout() {
System.out.println(this.name+"汪汪汪....");
}
}
class Test {
public static void main(String[] args) {
Animal animal = new Dog("wangcai",2);
if(animal instanceof Dog) {
Dog dog = (Dog) animal;
}
}所谓的多态其实就是向上转型加动态绑定