1 class 父类{ 2 } 3 class 子类 extends 父类{ 4 }
在Java中,类的继承是单一继承, 也就是说,一个子类只能拥有一个父类, 所以extends只能继承一个类。
1 public class Animal { 2 private String name ; 3 private int id: 4 public Animal() {} 5 public Animal (String myName,int myid) { 6 //初始化属性值. 7 } 8 public void eat() { //吃东西方法的具体实现 } 9 public void sleep() { //睡觉方法的具体实观} 10 } 11 12 public class Penguin extends Animal { 13 } 14
使用implements关键字可以变相的使java具有多继承的特性,使用范围为类继承接口的情况,可以同时继承多个接口(接口跟接口之间采用逗号分隔,下面例子中的A与B)。
1 public interface A { 2 public void eat() ; 3 public void sleep() ; 4 } 5 public interface B { 6 public void show() ; 7 } 8 public class C implements A, B{ 9 public void eat() {} 10 public void sleep() {} 11 public void show() {} 12 }
super关键字 : 我们可以通过super关键字来实现对父类成员的访问,用来引用当前对象的父类。
this关键字 : 指向自己的引用。
1 class Animal { 2 void eat() { 3 System.out.println(" animal : eat"); 4 } 5 } 6 class Dog extends Animal { 7 void eat() { 8 System.out.println(" dog : eat"); 9 } 10 void eatTest() { 11 this.eat(); // this 调用自己的方法. 12 super.eat(); // super 调用父类方法 13 } 14 } 15 Animal a = new Animal(); 16 a.eat(); 17 Dogd = new Dog(); 18 d.eatTest(); 19
1 class SuperC1ass { 2 private int n; 3 SuperClass() { 4 System.out.println("SuperClass()"); 5 } 6 SuperClass(int n) { 7 System.out.println("SuperClass(int n)"); 8 this.n = n; 9 } 10 } 11 // SubClass1类继承 12 class SubClass1 extends SuperClass { 13 private int n; 14 SubClass1(){ //自动调用父类的无参数构造器 15 System.out.println("SubClass1"); 16 } 17 public SubClass1(int n) { 18 super(300); //{ 调用父类中带有参数的构造器 19 System.out.println(”SubClass1(int n):" +n); 20 this.n = n; 21 } 22 } 23 // SubClass2类继承 24 class SubClass2 extends SuperClass { 25 private int n; 26 SubClass2() { 27 super(300); //{ 调用父类中带有参数的构造器 28 System.out.println("SubClass2"); 29 } 30 public SubClass2(int n){ //自动调用父类的无参数构造器 31 System.out.println("SubClass2(int n):" +n); 32 this.n= n 33 } 34 } 35 System.out.println("-----SubClass类继承-----"); 36 SubClass1 sc1 = new SubClass1(); 37 SubClass1 sc2 = new SubClass1(100); 38 System.out.println("-----SubC1ass2类继------"); 39 SubClass2 sc3 = new SubClass2(); 40 SubClass2 sc4 = new SubClass (200);
区别点 | 重载方法 | 重写方法 |
参数列表 | 必须修改 | 一定不能修改 |
返回类型 | 可以修改 | 一定不能修改 |
异常 | 可以修改 | 可以减少删除,一定不能抛出新的或者更广的异常 |
访问 | 可以修改 | 一定不能做更严格的限制(可以降低限制) |
重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改
变。即外壳不变,核心重写!
重写的好处在于子类可以根据需要,定义特定于自己的行为。也就是说子类能够根据
需要实现父类的方法。
1 class Animal { 2 public void move() { 3 System.out.println("动物可以移动"); 4 } 5 } 6 7 class Dog extends Animal { 8 public void move() { 9 System. out. print1n("狗可以跑和走"); 10 } 11 } 12 Animal a = new Animal(); // Animal对象 13 a.move(); //执行Animal类的方法 14 15 Animal b = new Dog(); //Dog对象 16 b.move(); //执行Dog类的方法 17
重载(overloading)是在一个类里面, 方法名字相同,而参数不同。返回类型可以相同
也可以不同。
每个重载的方法(或者构造函数)都必须有一个独一 无的参数类型列表。
最常用的地方就是构造器的重载。
1 public class Overloading { 2 public int test() { 3 System.out.println("test1"); 4 return 1; 5 } 6 public void test(int a) { 7 System.out.println("test2"); 8 } 9 //以下两个参数类型顺序不同 10 public String test(int a, String s) { 11 System.out.println("test3"); 12 return "returntest3"; 13 } 14 public String test (String s, int a) { 15 System.out.println(" test4"); 16 return "returntest4"; 17 } 18 } 19 Overloading o = new overloading(); 20 System.out.println(o.test()) ; 21 o.test(1); 22 System.out.println(o.test(1,"test3")); 23 System.out.println(o.test("test4",1)); 24