Java SE6.0 学习（继承）

 

1.protected类型只有在谈论继承的时候，才和默认类型有区别。其它情况此类型和默认类型均相同。该区别是：当成员变量被修饰为protected类型

时，若访问该变量的类位于包外，只有通过继承访问该变量(不能通过引用访问)。例如：
package wyf;
public class Sample8_5
{
 protected String str = "该成员变量为受保护类型，其在包内能够被成功继承!";
}

package jc;
import wyf.*;
class Sample8_5Son extends Sample8_5
{
 public void getShow()
 {
   System.out.println("/n子类内代码调用结果："+this.str);  //通过继承访问，编译通过
 }
}

public class Sample8_6
{
 public static void main(String[] args)
 {
  Sample8_5Son s = new Sample8_5Son(); 
  System.out.println("子类外代码调用结果："+s.str);  //该处通过子类类型的引用来调用，但这不是继承访问，故会编译报错
  s.getShow();  //调用子类方法
 }
}

2.super与this一样，也是一个预定义对象引用，只不过this表示自己这个对象，super表示父类对象。super只能在子类中使用，用来访问父类的成员

，通过使用super，可以成功调用父类被隐藏的成员变量。

3.所谓基于继承的多态是指：拿着父类的引用，可以根据需要将引用指向不同的子类对象，来调用不同的子类实现。

4.package wyf.jc;
public class Sample8_8
{
 public static void main(String[] args)
 {
  Car c=new Truck();
  System.out.println("访问的成员为："+c.aMember+"!");
 }   
}
class Car
{
 String aMember="我是汽车类的成员变量";
}
class Truck extends Car
{
 String aMember="我是卡车类的成员变量，汽车类也有";
}
该程序结果为：访问的成员为：我是汽车类的成员变量!
虽然对象是子类Truck类型的，但打印的是父类Car的成员变量。这是因为在运行时，对于成员变量的访问，系统认的是引用类型，引用是什么类型的

，系统就访问谁的成员。若要访问子类Truck对象的成员，则需要将指向对象的父类引用转换为子类类型。将第7行代码修改如下：
   System.out.println("访问的成员为："+((Truck)c).aMember+"!");

5.对象引用所能调用的成员的规则是，引用只能调用其所在的类具有的成员，不能调用子类特有的成员，这点对于成员变量和方法是一样的。例如：
package wyf.jc;
public class Sample8_10
{
 public static void main(String[] args)
 {
      Fruit f=new Apple();
      System.out.println("调用父类子类共有的成员变量name="+f.name);
      System.out.println("子类特有的成员变量aname="+f.aname);
 }   
}
//水果类
class Fruit
{
 String name="水果";
}
//苹果类
class Apple extends Fruit
{
 String name="苹果";
 String aname="苹果a";
}
上面的程序运行时会报“找不到符号”错误，这个因为虽然f引用指向的是apple对象，apple对象有aname属性，但这点编译时系统并不知道，系统只

能根据引用类型来判断，如果引用类型中没有该属性，则编译报错。

6.引用赋值时可以直接将子类引用赋给父类引用，若需将父类引用赋给子类引用则必须进行强制类型转换。

7.成员变量的调用按引用的类型；方法的调用按对象的类型，无论使用什么类型的引用，其调用的都是具体对象所在类中定义的方法。例如：
package wyf.jc;
class Vehicle
{
 public void startUp()
 {
  System.out.println("一般交通工具的启动方法！！！");
 }
}
class Car extends Vehicle
{
 public void startUp()
 {
  System.out.println("轿车的启动方法！！！");
 }
}
public class Sample8_15
{
 public static void main(String[] args)
 {
  //创建对象并调用方法
  Vehicle v =new Car();
  System.out.print("实际调用的方法为：");
  v.startUp();
 }
}

运行结果为：轿车的启动方法！

8.java中静态方法可以被继承，但没有重写。当子类中重写的方法也是静态的时候，其实质是将父类的静态方法隐藏，而并非是将其重写，例如：
package wyf.jc;
class Car
{
 //brake静态方法
 public static void brake()
 {
  System.out.println("正在汽车上刹车！！");
 }
 //startUp静态方法
 public static void startUp()
 {
  System.out.println("正在汽车上启动！！");
 }
}
// Truck类继承自Car类
class Truck extends Car
{
 //定义brake静态方法
 public static void brake()
 {
  System.out.println("正在卡车上刹车！！");
 }
}
public class Sample8_22
{
 public static void main(String[] args)
 {
  //调用方法
  Truck t=new Truck();
  Car c=t;
  System.out.print("t.brake()调用的为：");
  //使用引用t调用Truck 对象中的brake方法
  t.brake();
  System.out.print("t.startUp()调用的为：");
  //使用引用t调用Truck 对象中的startUp方法
  t.startUp();  
  System.out.print("c.brake()调用的为：");
  //使用引用c调用Truck 对象中的brake方法
  c.brake();
 }
}
运行结果为：t.brake()调用的为：正在卡车上刹车！！
            t.startUp()调用的为：正在汽车上启动！！
            c.brake()调用的为：正在汽车上刹车！！
说明：在调用子类和父类都有的break()方法时，用父类引用的是父类方法，用子类引用的是子类方法，与对象的类型无关，这与非静态方法不同。
      当用子类引用调用子类本身没有，父类有且可继承的startUp()方法时，调用的是从父类继承的方法。
提示：读者要区分好隐藏和重写，隐藏是根据引用的类型来进行调用，重写是根据对象的类型来进行调用。

 

9.对于具有重载方法的类，具体要调用哪个方法是由参数序列来决定的。参数可以是基本数据类型，也可以是对象引用，对于参数是对象引用的方法

来说，一样是由参数类型决定调用哪个方法。与基本类型相同，如果给的参数没有完全匹配的，会尽可能找出最兼容参数的方法。例如：
package wyf.jc;
class Vehicle{}
//Car类继承自Vehicle类
class Car extends Vehicle{}
//Truck类继承自Car类
class Truck extends Car {}
class UseCar
{
 //该方法参数为Vehicle型
 public void show(Vehicle v)
 {
  System.out.println("调用的是具有Vehicle参数的方法！！！");
 }
 //该方法参数为Car型
 public void show(Car c)
 {
  System.out.println("调用的是具有Car参数的方法！！！");
 }
}
public class Sample8_25
{
 public static void main(String[] args)
 {
  //创建对象，调用方法
  UseCar a=new UseCar();
  //声明Vehicle类引用并将其指向该类的对象
  Vehicle v=new Vehicle();
  //声明Car类引用并将其指向该类的对象
  Car c=new Car();
  //声明Truck类引用并将其指向该类的对象
  Truck t=new Truck();
  System.out.print("用Vehicle类型参数调用：");
  //使用引用v作为参数调用show方法
  a.show(v);
  System.out.print("用Car类型参数调用：");
  //使用引用c作为参数调用show方法
  a.show(c);
  System.out.print("用Truck类型参数调用：");
  //使用引用t作为参数调用show方法
  a.show(t);

                v = new UseCar();   //将Vehicle类引用指向UseCar类的对象
                a.show(v); //使用引用v作为参数调用show方法。该处由引用类型决定调用哪个重载方法，而不是对象类型决定。故结果为：调用 

                         //的是具有Vehicle参数的方法
 }
}

10.用final修饰的类不能被继承，只有当需要确保类中的所有方法都不要被重写改进时才应该建立final类；
   用final修饰方法时，该方法在子类中无法重写，只能被继承；

11.抽象方法是只有声明，没有方法体的，声明格式为：
 public abstract void Method();
抽象方法只能存在于抽象类中；
抽象类中可以有非抽象的方法，且非抽象方法往往是抽象类所有未来子类都具体有的，不会因子类的不同而具体实现不同的方法；
抽象类中的抽象方法没有方法体，也就是没有方法的实现，是因为这些方法会因为子类的不同而具体实现不同。

12.在java开发中，基于继承的多态就是指对象功能的调用者用超类的引用来进行方法调用。
package wyf.jc;
//定义抽象类Car
abstract class Car
{
 //定义抽象方法brake
 public abstract void brake();
}
//定义非抽象类Truck继承自Car类
class Truck extends Car
{
 //实现brake方法
 public void brake()
 {
  System.out.println("正在卡车上刹车！！");
 }
}
//定义非抽象类Mini继承自Car类
class Mini extends Car
{
 ////实现brake方法
 public void brake()
 {
  System.out.println("正在面包车上刹车！！");
 }
}
public class Sample8_32
{
 public static void main(String[] args)
 {
  //声明Car引用c并将其指向Truck类的对象
  Car c=new Truck();
  System.out.print("调用的方法为：");
  //使用引用c调用brake方法
  c.brake();
       
  //将引用c指向Mini类的对象
  c=new Mini();
  System.out.print("调用的方法为：");
  //使用引用c调用brake方法
  c.brake();
 }
}