java基础知识--继承

继承

　

1、继承的概念

继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

　　1、类的继承格式

　　　　在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的，一般形式如下：　　　

class 父类 {
}
 
class 子类 extends 父类 {
}

　　2、继承的特性　　

• • 子类拥有父类非private的属性，方法。

  • 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

  • 子类可以用自己的方式实现父类的方法。

  • Java的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如A类继承B类，B类继承C类，所以按照关系就是C类是B类的父类，B类是A类的父类，这是java继承区别于C++继承的一个特性。

  • 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系）　

　　3、继承关键字

　　继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，

　　则默认继承object（这个类在 java.lang 包中，所以不需要 import）祖先类。

　　extends关键字

　　　　在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。　　　　　

public class Animal { 
    private String name;   
    private int id; 
    public Animal(String myName, String myid) { 
        //初始化属性值
    } 
    public void eat() {  //吃东西方法的具体实现  } 
    public void sleep() { //睡觉方法的具体实现  } 
} 
 
public class Penguin  extends  Animal{ 
}

　　implements关键字

　　　　使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。　　

implements 关键字
public interface A {
    public void eat();
    public void sleep();
}
 
public interface B {
    public void show();
}
 
public class C implements A,B {
}

2、Java中构造器

　　 1、概念　　

　　又称为 构造方法，constructor   构造器用于构造该类的实例。

　　构造器是一个创建对象时被自动调用的特殊方法，为的是初始化。构造器的名称应与类的名称一致。　

 　　当创建一个个对象时，系统会该对象的属性默认初始化，基本类型属性的值为0（数值类型），false（布尔类型），把所有的引用类型设置为null.

       构造器可以改变这种默认的初始化。

　　2、构造器的语法格式的详细说明

修饰符： 修饰符可以省略，也可以是public，protected，private其中之一
构造器名：构造器名必须和类名相同
形参列表：和定义方法形参列表的格式完全相同

指的指出的是，构造器不能定义返回值类型声明，也不能声明void定义构造器没有返回值，

如果为构造器定义了返回值类型，或者使用了void定义构造器没有返回值，编译时不会出错

但java会把这个所谓的构造器当做方法来处理

3、构造器与方法的不同

　　　　

　　4、应用

　　　　实例演示：计算坐标点的距离

　　　　实体类Point代码：　　

1 public class Point {
 2 
 3     // 点的属性 横纵坐标
 4     int x;
 5     int y;
 6     
 7     // 默认无参构造器 
 8     public Point(){
 9         System.out.println("默认构造。");
10     }
11     
12     // 有参构造1
13     public Point(int a,int b){
14         System.out.println("有参构造。");
15         // 给对象赋值 
16         x = a;
17         y = b;
18     }
19     // 有参构造2（重载）
20     public Point(int a){
21 //        System.out.println();
22         this(a,a); // 重载 调用上面的有参构造1(此语法专门用来构造方法间调用，必须写在构造方法的第一行)
23     }
24     
25     /**
26      * 点距离的计算方法
27      * 参数分别为：无参 点坐标 点对象
28      * 方法重载
29      */
30     public double distance(){ // 无参
31         return Math.sqrt(Math.pow(this.x, 2) + Math.pow(this.y, 2)); // 到原点的距离
32     }
33     
34     // 到某个点的距离
35     public double distance(int a, int b){ // 参数为点坐标
36         return Math.sqrt(Math.pow(this.x-a, 2)+Math.pow(this.y-b, 2));
37     }
38     
39     public double distance(Point p){ // 参数为点对象
40         return distance(p.x, p.y);
41     }
42     
43 }

PrintDemo　

1 public class PointDemo {
 2     public static void main(String[] args) {
 3         
 4         Point p1 = new Point(3,2);
 5         System.out.println("p1的坐标是：" + "(" + p1.x + "," + p1.y + ")");
 6         
 7         Point p2 = new Point(5);
 8         System.out.println("p2的坐标是：" + "(" + p2.x + "," + p2.y + ")");
 9         
10         /**
11          * 求点到点的距离
12          */
13         Point p = new Point(6,8);
14         System.out.println("到原点的距离为：" + p.distance()); // 到原点的距离
15         System.out.println("到另一个点的距离为：" + p.distance(3, 3)); // 到(3,3)的距离 
16         System.out.println("到某个点对象的距离为：" + p.distance(p2)); // 到点对象p2的距离
17     }
18 }

 　　输出为：

　　　　有参构造。
　　　　p1的坐标是：(3,2)
　　　　有参构造。
　　　　p2的坐标是：(5,5)
　　　　有参构造。
　　　　到原点的距离为：10.0
　　　　到另一个点的距离为：5.830951894845301
　　　　到某个点对象的距离为：3.1622776601683795

3、java中的this和super

　　1、this关键字

　　　　this 关键字表示当前对象。可用于：

• • 调用当前类的构造方法，并且必须是方法的第一条语句。如：this(); 调用默认构造方法。this(参数); 调用带参构造方法。
  • 限定当前对象的数据域变量。一般用于方法内的局部变量与对象的数据域变量同名的情况。如 this.num = num。this.num 表示当前对象的数据域变量 num，而 num 表示方法中的局部变量。

　　　2、super 关键字

　　　　super 表示使用它的类的父类。super 可用于：

• • 调用父类的构造方法；
  • 调用父类的方法（子类覆盖了父类的方法时）；
  • 访问父类的数据域（可以这样用但没有必要这样用）。

　　　调用父类的构造方法语法：　　　

super();  

或   

super(参数列表);

　　　　注意：super 语句必须是子类构造方法的第一条语句。不能在子类中使用父类构造方法名来调用父类构造方法。 父类的构造方法不被子类继承。

　　　　　　　　调用父类的构造方法的唯一途径是使用 super 关键字，如果子类中没显式调用，则编译器自动将 super(); 作为子类构造方法的第一条语句。

　　　　　　　　　　这会形成一个构造方法链。

　　　　　　　　静态方法中不能使用 super 关键字。

　　调用父类的方法语法：

　　　　super.方法名(参数列表);

　　　　如果是继承的方法，是没有必要使用 super 来调用，直接即可调用。但如果子类覆盖或重写了父类的方法，则只有使用 super 才能在子类中调用父类中的被重写的方法。