Java面向对象，继承，多态

1,继承

Java 中经过 extends 关键字能够继承一个类，implements能够继承多个接口。继承容许建立等级层次的类。

继承的机制提升了代码的复用性，让类与类之间产生了关系，有了这个关系，才有了多态的特性。

注：Java支持单继承，可是能够多层继承。

子类能够拥有父类的非private的方法和属性，子类能够继承父类的方法，也能够重写父类的方法，还能够对父进行拓展。

增长了类之间的联系，即提升了耦合。

通常格式为：

class 父类 { }

class 子类 extends 父类 { }

 

Demo1:

 1 package com.hpioneer.Demo;
 2 
 3 public class Test_Extends {
 4     public static void main(String[] args) {
 5         Zi z = new Zi();
 6         //z.show();
 7     }
 8 }
 9 class Fu {
10     static {
11         System.out.println("静态代码块Fu");
12     }
13 
14     {
15         System.out.println("构造代码块Fu");
16     }
17 
18     public Fu() {
19         System.out.println("构造方法Fu");
20     }
21 }
22 
23 class Zi extends Fu {
24     static {
25         System.out.println("静态代码块Zi");
26     }
27 
28     {
29         System.out.println("构造代码块Zi");
30     }
31 
32     public Zi() {
33         System.out.println("构造方法Zi");
34     }
35 }

Demo2:

super关键字能够用来实现对父类成员的访问，来引用当前对象的父类。this关键字用于指向本身。

super能够调用父类的构造方法，方法（和子类相同的，被重写）

 1 class Animal {
 2   void eat() {
 3     System.out.println("animal : eat");
 4   }
 5 }
 6  
 7 class Dog extends Animal {
 8   void eat() {
 9     System.out.println("dog : eat");
10   }
11   void eatTest() {
12     this.eat();   // this 调用本身的方法
13     super.eat();  // super 调用父类方法
14   }
15 }
16  
17 public class Test {
18   public static void main(String[] args) {
19     Animal a = new Animal();
20     a.eat();
21     Dog d = new Dog();
22     d.eatTest();
23   }
24 }

2,重载（Override）和重写（Overload）

重写是对父类容许的方法的实现从新编写，返回值和参数都不能改变。

重载是一个类里面，方法名相同，参数不一样，返回值类型也能够不一样。

方法的重写和重载是java多态性的不一样表现，重写是父类与子类之间多态性的一种表现，重载能够理解成多态的具体表现形式。

　　(1)方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不一样或数量相同而类型和次序不一样,则称为方法的重载(Overloading)。

　　(2)方法重写是在子类存在方法与父类的方法的名字相同,并且参数的个数与类型同样,返回值也同样的方法,就称为重写(Overriding)。

　　(3)方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。

 3,多态

多态是同一行为具备多个表现形式。

多态的前提：必需要有关系，好比继承，实现等，一般会有覆盖操做。

多态的实现方法：

　　一，重写

　　二，接口

　　三，抽象方法和抽象类

 

4,抽象类

 

抽象类通常用于描述一个体系单元，将一组共性内容进行抽取，在Java语言中使用abstract class来定义抽象类。

特色：能够在类中定义抽象内容让子类实现，能够定义非抽象内容让子类直接使用。它里面定义的都是一些体系中的基本内容。抽象类不能实例化对象，因此抽象类必须被继承，才能被使用。

Demo:

 1 abstract class Animal{
 2   private int age = 10;
 3   public Animal(){
 4     System.out.println("初始化Animal");
 5   }
 6   public void move(){
 7     System.out.println("跑步数："+this.age);
 8   }
 9 }
10 
11 abstract class Dog extends Animal{
12   public Dog(int age){
13    // super(age);//去掉会报异常
14     System.out.println("初始化Dog");
15   }
16 
17 }
18 
19 public class BigDogs extends Dog{
20   public BigDogs(){
21     super(20);
22     System.out.println("初始化BigDog");
23   }
24 
25   public static void main(String[] args){
26     BigDogs a = new BigDogs();
27     a.move();
28   }
29 }