学习问题记录(2) -- 类的访问权限，继承和多态

 

 

Java的访问控制修饰符有哪些？各有什么访问权限？

A:    在 Java 语言中提供了多个作用域修饰符，其中常用的有 public、private、protected、final、abstract、static、transient 和 volatile，这些修饰符有类修饰符、变量修饰符和方法修饰符。

为了用代码对比出其中的区别，首先建立两个包，分别为area1和area2；五个类，分别是Person、PersonDemo、PersonSon、PersonTest、OutPerson。

然后Person、PersonDemo、PersonSon放在area1包下。

PersonTest、OutPerson放在area2包下。

四个访问控制修饰符在同类下的代码例子：

 

package area1;
public class Person {
    public String _public="公共变量"; //定义一个公共变量
    private String _private="私有变量"; //定义一个私有变量
    protected String _protected="保护变量 "; //定义一个保护变量
    String _default="默认变量"; //使用默认方法定义变量
    public void _pub(){ //创建一个公共方法
        System.out.println(_public);
    }
    private void _pri(){ // 创建一个私有方法
        System.out.println(_private);
    }
    protected void _pro(){ //创建一个保护方法
        System.out.println(_protected);
    }
    void _def(){ //创建默认方法
        System.out.println(_default);
    }
    public static void main(String[] args){
        Person p=new Person(); //创建对象
        p._pub();  //调用方法
        p._pri();
        p._pro();
        p._def();
    }
} 

 

 

四个访问控制修饰符在同包不同类（不含子类）下的代码例子：

 

package area1;
public class PersonDemo {
    public static void main(String[] args){
        Person p=new Person();  //创建Person类的对象
        p._pub();
        p._pri(); //报错
        p._pro();
        p._def();
    }
} 

 

四个访问控制修饰符在同包子类下的代码例子：

 

 

package area1;
public class PersonSon extends Person{ //子类PersonSon继承父类Person
    public static void main(String[] args){
        PersonSon son=new PersonSon(); //子类创建对象
        son._pub();
        son._pro();
        son._def();
        son._pri();  //报错
        Person father=new Person(); //父类创建对象
        father._def();
        father._pub();
        father._def();
        father._pri();  //报错
    }
} 

 

四个访问控制修饰符在同包不同类（不含子类）下的代码例子：

 

 

package area2;
import area1.Person; //引用area1包下的Person类
public class PersonTest {
    public static void main(String[] args){
        Person p=new Person(); //Person类创建对象
        p._pub();
        p._pro();  //报错
        p._pri();  //报错
        p._def();  //报错
    }
}

 

四个访问控制修饰符在同包子类下的代码例子：

 

 

package area2;
import area1.Person; //引用area1包下的Person类
public class OutPerson extends Person{ //子类继承父类
    public static void main(String[] args){
        OutPerson out=new OutPerson(); //子类创建对象
        out._pub();
        out._pro();
        out._pri();  //报错
        out._def();  //报错
    }
}

 

子类对于从父类继承的哪些属性与方法是可见的？

A  :子类继承父类的所有的非私有的方法和属性。

class A{
     private int a = 0;
     public int b  = 0 ;
     protected int c = 0;     
}

class B extends A{
     //可以调用 b,c,d     不能调用 a
}

 

什么是组合？有什么作用？

组合即把一个类当成另一个类的组合成分，从而允许新类直接复用该类的public方法。

不破坏封装，整体类与局部类之间松耦合，彼此相对独立且具有更好的可扩展性。

 

class A{
     public void fun(){
             \\.....
     }
}


class B{
     A  a = new A();
     a.fun();\\ 就是组合。
}

 

什么是重载？有什么作用？

重载时根据参数的不同，进而方法不同。

重载方法的三种方法

为了重载方法，方法的参数列表必须在以下两个方面有所不同：

1.参数数量。

例如：

add(int, int)
add(int, int, int)

 

2.参数的数据类型。

例如：

add(int, int)
add(int, float)

 

3.参数的数据类型顺序。

例如：

add(int, float)
add(float, int)

注意下面是无效重载情况：

int mymethod(int a, int b, float c)
int mymethod(int var1, int var2, float var3)

 

什么是覆盖？有什么作用？

子类重写父类的同名方法   叫做覆盖，覆盖是为了子类实现与父类同名而不同过程的方法

class Parent {
   public int getScore()
   { return 3; }
   public String getCountryName()
   { return “China”; }
}
class Son extends Parent {
    public int getScore(){
      return 4;
    }
 }
 public class RunSon{
    public static void main(String args[]){
      Son  s = new Son();
      System.out.println(s.getScore());
      System.out.println(s.getCountryName()); 
     }