JAVA基础教程（7）

继承与访问权限继承的概念:
继承是一种由己有的类创建新类的机制.利用继承,可以先创建一个共有属性的一般类,根据该一般类再创建具有特殊属性的新类,新类继承一般类的状态和行为,并根据需要增加它自己的新的状态和行为.由继承而得到的类称为子类,被继承的类称为父亲.java不支持多重继承,即子类只能有一个父亲(有别于C++的语法).子类:
在类的声明中,通过使用关键字extends来声明一个类的子类,格式为:
class  子类名  extends  父类名
{
//...
}注:如果一个类声明中没有使用extends关键字,这个类被系统默认为是Object的直接子类,Object是java.lang包中的类子类的继承性
所谓子类的继承父类的成员变量作为自己的一个成员变量,就好像它们是在子类中直接声明一样,可以被子类中自己声明的任何实例方法操作,也就是说,一个子类继承的成员应当是这个类的完全意义的成员,如果子类中声明的实例方法不能操作父类的某个成员变量,该成员变量就没有被子类继承;所谓子类继承父类的方法作为子类中的一个方法,就象它们在子类中直接声明一样,可以被子类中自己声明的任何实例方法调用.1) 子类和父类在同一包中的继承性
如果子类和父类在同一包中,那么子类自然地继承了其父类中不是private的成员变量作为自己的成员变量,并自然地继承了其父类中不是private的成员方法作为自己的成员方法,继承的成员的访问权限保持不变.  例如:
复制代码
class Father
{  private int money;
   float weight,height;
   String head;
   void speak(String s)
{  System.out.println(s);
   }
}
class Son extends Father
{   String hand,foot;
}
public class Example4_15
{  public static void main(String args[])
{  Son boy;
      boy=new Son();
      boy.weight=1.80f;
      boy.height=120f;
      boy.head="一个头";
      boy.hand="两只手 ";
      boy.foot="两只脚";
      boy.speak("我是儿子");
      System.out.println(boy.hand+boy.foot+boy.head+boy.weight+boy.height);
   }
}    


2)子类和父类不在同一个包中的继承性
如果子类和父类不在同一个包中,那么,子类继承了父亲的protected,public成员变量和成员方法作为子类的成员变量和方法,继承的成员或方法的访问权限保持不变.如果子类和父类和父类不在同一包中,子类不能继承父类的友好变量和友好方法.

上面提到的private,protected,public以及友好(friendly)等字眼就是访问权限,下面来讲解一下他们具体的意义

当一个类创建了一个对象之后,该对象可以通过"."运算符操作自己的变量,使用类中的方法,但对象操作自己变量和使用类中的方法是有一定限制的.所谓访问权限是指对象是否可以通过"."运算符作自己的变量或使用类中的方法.访问权限的修饰符有private,protected和public,都些都是java中的关键字,还有就是友好(friendly)但它不是关键字只是种默认时的权限.访问权限由高到低:public->protected->friendly->private
具体分析如下:
用关键字private修饰的成员变量和方法称为私有变量和方法.如
class room
{private float weight;
private float f(float a,float b){//....}
}
当在另外一个类中用类Tom创建一个对象后,该对象不能访问自己的私有变量和私有方法.如
class jerry
{void g()
{Tom cat=new Tom;
cat.weight=23f;//错误,因为weight被私有修饰,不可一被对象访问
cat.f(3f,4f);//错误,f()被private修饰,不能被使用
}
}
对于私有成员变量或方法,只有在本类中创建该类的对象时,这个对象才能访问自己的私有成员变量和类中的私有方法.如

复制代码
class Example4_14//所有代码都包含在一个类中
{   private int money;
Example4_14()
{  money=2000;
    }  
private int getMoney()
{  return money;
    }
public static void main(String args[])
{  Example4_14 exa=new Example4_14();
exa.money=3000;
int m=exa.getMoney();
       System.out.println("money="+m);
    }
}


当然如果类中只有变量是私有的,而能操作此变量的函数是共有的,就可以间接对此私有变量进行操作

复制代码
class room
{private float weight;
float f(float weight){this.weight=weight;}//都在一个类中方法可以访问变量
}
class jerry
{void g()
{Tom cat=new Tom;
cat.f(23f);//正确,f()没有被private修饰可以访问,这样就间接的操作了weight,相当于cat.weight=23f;
}
}


公有关键字public顾名思义,是访问权限最大的了,只要被它修饰无论在哪里都可以访问到
class room
{public float weight;
public float f(float a,float b){//....}
}
class jerry
{void g()
{Tom cat=new Tom;
cat.weight=23f;//正确
cat.f(3f,4f);//正确
}
}
友好(friendly)的概念,即不被private,protected,public修饰的成员变量和方法被称为友好变量和友好方法,如.
class room
{float weight;//友好变量
float f(float a,float b){//....}//友好方法
}
当在另一个类中用类Tom创建了一个对象后,如果这个类与Tom类在同一个包中,那么该对象能访问自己的友好变量和友好方法.在任何一个与Tom同一个包中的类,也可以通过Tom类的类名访问Tom类的类友好成员变量和类友好方法.
假如jerry和Tom是同一个包中的类,那么下述jerry类中的cat.weight.cat.f(3,4)都是合法的
class jerry
{void g()
{Tom cat=new Tom;
cat.weight=23f;//正确
cat.f(3f,4f);//正确