第五节课

 首先声明:java中,friendly这个修饰符并没有显式的声明,在成员变量和方法前什么修饰符也不用,默认的就是friendly。
   
为了条理清晰,分三种不同情况来总结。

访问权限

继承与访问权限

   一
访问权限修饰符修饰成员变量和方法
   public:表明该成员变量和方法是共有的,能在任何情况下被访问。
   
   protected:必须在同一包中才能被访问。(说的比较简单,看个例子就明白了)    
       eg:class A
          { 
            protected int weight ;
            protected int f( int a,int b   )   
            {
              // 方法体
            }
           }      
       假设B与A在同一个包中,则
           class B
          {
            void g()
            {
              A a=new A();
              A.weight=100;//合法
              A.f(3,4);    //合法
             }
           }
   特别说明:什么是在同一个包中?
   答:用package打包在一起的class ,叫在同一个包中。(不明白,举个例子)
      
eg:在JDK的srcjavaio中,你会看到许多java类,第一句源代码都是package
java.io;
       没有使用package打包的,在同一目录下的类也会被视做同一个包。
   
   friendly:在这种情况下中,同protected。区别在第二和第三种情况中。 
       eg: class A
          { 
            int weight ;
            int f( int a,int b   )   
            {
              // 方法体
            }
           }      
       假设B与A在同一个包中,则
           class B
          {
            void g()
澳门新葡萄京所有网站,            {
              A a=new A();
              A.weight=100;//合法
              A.f(3,4);    //合法
             }
           }
    private: 只能在本类中访问。
             eg:    class   Test
                    {  
                       private int money;
                       Test()
                       {
                          money=2000;
                       }
                       private int getMoney()
                       {
                         return money;
                        }
                     public  static  void main(String args[])
                     {
                         Test te=new  Test();
                         te.money=3000;             //合法
                         int m=te.getMoney();       //合法
                         System.out.println(“money=”+m);
                      }
                     }
                   
   PS:
实际上,把重要的数据修饰为private,然后写一个public的函数访问它,正好体现了OOP的封装特性,是OOP安全性的体现。
   

当用一个类创建了一个对象之后,该对象可以通过“.”运算符操作自己的变量、使用类中的方法,但对象操作自己的变量和使用类中的方法是有一定限制的。所谓访问权限是指对象是否可以通过“.”运算符操作自己的变量或通过“.”运算符使用类中的方法。

继承的概念:
继承是一种由己有的类创建新类的机制.利用继承,可以先创建一个共有属性的一般类,根据该一般类再创建具有特殊属性的新类,新类继承一般类的状态和行为,并根据需要增加它自己的新的状态和行为.由继承而得到的类称为子类,被继承的类称为父亲.java不支持多重继承,即子类只能有一个父亲(有别于C++的语法).

二 
访问权限修饰符修饰类
   1,不能用protected和private修饰类。
  
2,用friendly修饰的类叫友好类,在另外一个类中使用友好类创建对象时,要保证它们在同一包中。
  

访问限制修饰符有private、protected和public,都是Java的关键字,用来修饰成员变量或方法。

子类:
在类的声明中,通过使用关键字extends来声明一个类的子类,格式为:
class  子类名  extends 父类名
{
//…
}

三  
访问权限修饰符与继承
   这里的访问修饰符指的是修饰成员变量和方法。可以分为两种情况:
   1,子类与父类在同一包中
    此时只有声明为private的变量与方法不能被继承(访问)。
   eg:
     class Father
     {
       private int money ;
       int weight=100;
       
      }
     class Son extends Father
     {
       viod f()
       {
         money=10000;//   非法
         weight=100; //   合法
        }
      }
    2,子类与父类不在同一包中
    此时private与friendly均不能被继承(访问), protected与public可以。
     eg:
       Father.java

私有变量和私有方法

注:如果一个类声明中没有使用extends关键字,这个类被系统默认为是Object的直接子类,Object是java.lang包中的类

      package com.aaa
      public class Father
     {
       int height ;
       protected  int money=120;
       public int weight;
       protected int getMoney()
       {
         return money;
       }
       void setMoney(int newMoney)
       {
         money=newMoney;
       }
      }
     
      Son.java
      package com.bbb
      import com.aaa.Father;
      public class Son extends Father
      {
         void f()
         {
           money=10000;//合法
           //height=170;//非法,height为friendly修饰的变量
           System.out.println(money);//输出结果是10000
           //setMoney(300);          //非法
           int number=getMoney();    //合法
           System.out.println(number);//输出结果是10000
          }
           public  static  void main(String args[])
          {
            Son sss=new Son();
            sss.f();
           }
       }
  所以,访问权限修饰符权限从高到低排列是public 
,protected  ,friendly, private。

用关键字private修饰的成员变量和方法称为私有变量和私有方法。

子类的继承性
所谓子类的继承父类的成员变量作为自己的一个成员变量,就好像它们是在子类中直接声明一样,可以被子类中自己声明的任何实例方法操作,也就是说,一个子类继承的成员应当是这个类的完全意义的成员,如果子类中声明的实例方法不能操作父类的某个成员变量,该成员变量就没有被子类继承;所谓子类继承父类的方法作为子类中的一个方法,就象它们在子类中直接声明一样,可以被子类中自己声明的任何实例方法调用.

对于私有成员变量或方法,只有在本类中创建该类的对象时,这个对象才能访问自己的私有成员变量和类中的私有方法。

1) 子类和父类在同一包中的继承性
如果子类和父类在同一包中,那么子类自然地继承了其父类中不是private的成员变量作为自己的成员变量,并自然地继承了其父类中不是private的成员方法作为自己的成员方法,继承的成员的访问权限保持不变.  例如:

class Tom {

程序代码:

private float weight;

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);
   }
}    

private float f(float a,float b){

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

return a+b;

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

}

当一个类创建了一个对象之后,该对象可以通过”.”运算符操作自己的变量,使用类中的方法,但对象操作自己变量和使用类中的方法是有一定限制的.所谓访问权限是指对象是否可以通过”.”运算符作自己的变量或使用类中的方法.访问权限的修饰符有private,protected和public,都些都是java中的关键字,还有就是友好(friendly)但它不是关键字只是种默认时的权限.访问权限由高到低:public->protected->friendly->private
具体分析如下:

}

关键字private修饰的成员变量和方法称为私有变量和方法.如

class Jerry {

class room
{private float weight;
private float f(float a,float b){//….}
}

void g() {

当在另外一个类中用类Tom创建一个对象后,该对象不能访问自己的私有变量和私有方法.如
class jerry
{void g()
{Tom cat=new Tom;
cat.weight=23f;//错误,因为weight被私有修饰,不可一被对象访问
cat.f(3f,4f);//错误,f()被private修饰,不能被使用
}
}

Tom cat=new Tom();

对于私有成员变量或方法,只有在本类中创建该类的对象时,这个对象才能访问自己的私有成员变量和类中的私有方法.如

cat.weight=23f; //非法

程序代码:

float sum=cat.f(3,4); //非法

class Example4_14//所有代码都包含在一个类中
{   private int money;
Example4_14()
{  money=2000;
    }  
private int getMoney()
{  return money;
  &nbsp

}

}

共有变量和共有方法

用public修饰的成员变量和方法被称为共有变量和共有方法 。

我们在任何一个类中用类Tom创建了一个对象后,该对象能访问自己的public变量和类中的public方法(也可以通过类名来操作成员变量、方法)

class Tom {

public float weight;

public float f(float a,float b) {

return a+b;

}

}

class Jerry {

void g() {

Tom cat=new Tom();

cat.weight=23f; //合法

float sum=cat.f(3,4); //合法

}

}

受保护的变量和方法

用protected修饰的成员变量和方法被称为受保护的成员变量和受保护的方法 。

我们在任何一个类中用类Tom创建了一个对象后,如果这个类和类Tom在同一个包中,那么该对象能访问自己的protected变量和类中的protected方法。

class Tom {

protected float weight;

protected float f(float a,float b) {

return a+b;

}

}

class Jerry {

void g() {

Tom cat=new Tom();

cat.weight=23f; //合法

float sum=cat.f(3,4); //合法

}

}

友好变量和友好方法

不用private、public、protected修饰的成员变量和方法被称为友好变量和友好方法。

我们在任何一个类中用类Tom创建了一个对象后,如果这个类和类Tom在同一个包中,那么该对象能访问自己的友好变量和类中的友好方法。

class Tom {

float weight;

float f(float a,float b) {

return a+b;

}

}

class Jerry {

void g() {

Tom cat=new Tom();

cat.weight=23f; //合法

float sum=cat.f(3,4); //合法

}

}

Public类和友好类

类声明时,如果在关键字class前面加上public关键字,就称这样的类是一个public类

可以在任何另外一个类中,使用public类创建对象。

如果一个类不加public修饰,这样的类被称作友好类。

在另外一个类中使用友好类创建对象时,要保证它们是在同一包中。

注:

(1)不能用protected和private修饰类

(2)访问限制修饰符按访问权限从高到低的排列顺序是:public、ptotected、友好的、private。

原文链接:http://www.maiziedu.com/wiki/java/access/