java extends无法访问 java中无法访问的语句

1.Java的访问控制修饰符有哪些？各有什么访问权限？
Java有四种访问权限， 其中三种有访问权限修饰符，分别为private，public和protected，还有一种不带任何修饰符。
public：修饰类方法变量，对应的访问权限是：全部包的任何类
protected：用protected修饰的类、方法、变量，包内的任何类以及包外继承了该类的子类才能进行访问，重点是：包外继承了该类的子类才可以进行访问，意思是protected修饰的类中的方法和成员变量，只能被子类访问，不论这个子类和父类是否在同一个包中
default: 如果类、方法、变量没有使用任何访问修饰符，对应的访问修饰符就是default，只有包内的任何类可以进行访问
private：用private修饰的类、方法、变量、只有本类中可以访问，包内包外的任何类都不能进行访问的

package A;
public class test1{
    public String name;
    protected int age;
    private int score;
    public test1(String name,int age,int score){
        this.name=name;
        this.age=age;
        this.score=score;
    }
    public String getName(){
        return name;
    }
    protected int getAge(){
        return age;
    }
    private int getScore(){
        return score;
    }
}

package B;
import A.test1;
public class test2 extends test1{
    public int value;
    public test2(String name,int age,int score,int value){
        super(name,age,score);
        this.value=value;
    }
    public static  void main(String[] args) {
        test1 t1=new test1("abc",18,99);
        //test1.name--public
        System.out.println(t1.name);
        //test1.score--private
        System.out.println(t1.score);//The field test1.score is not visible
        //test1.name--protected
        System.out.println(t1.age)//The field test1.age is not visible
        test2 t2=new test2("abc",19,100,89);
        //子类可以访问protected修饰的方法或属性
        System.out.println(t2.age);
        System.out.println(t2.getAge());
    }
}

2.子类对于父类继承的哪些属性和方法是可见的？
子类继承了父类的所有属性和方法， 但只有public、protected的属性和方法在子类是可见的。
即初始化对象时，私有保护数据类型也要为其分配空间，只是不可见
子类在继承父类的时候，首先应该满足父类可被访问，例如当子类和父类不在同一个包当中时，父类修饰符必为public；在父类能被访问的前提下，凡是修饰符为public或是protected的父类属性成员或是方法能被子类所访问；private的属性成员或是方法则不能被直接访问。子类不能直接访问父类的private属性和方法，可以调用父类的公共方法来间接访问私有属性

package A;
class Parent{
    public String name;
    protected int age;
    private int score;
    public Parent(String name,int age,int score){
        this.name=name;
        this.age=age;
        this.score=score;
    }
    public String getName(){
        return name;
    }
    protected int getAge(){
        return age;
    }
    public int getScore(){
        return score;
    }
}
class Student extends Parent{
    public Student(String name,int age,int score){
        super(name,age,score);
    }
}
public class test1{
    public static void main(String[] args) {
        Student stu=new Student("abc",100,19);
        System.out.println(stu.name);//public
        System.out.println(stu.age);//protected
        System.out.println(stu.score);//The field Parent.score is not visible
        System.out.println(stu.getScore());//通过调用父类的公共方法来间接访问私有属性
    }
}

3.什么是组合？有什么作用？
组合(Composition)，java代码复用的一种方法。顾名思义，就是使用多个已有的对象组合为一个功能更加复杂强大的新对象。体现的是整体与部分、拥有的关系。又因为在对象之间，各自的内部细节是不可见的，所以我们也说这种方式的代码复用是黑盒式代码复用。
即一个对象作为另外的对象的一个属性

package A;
class Student{
    public String name;
    protected int age;
    private int score;
    public Student(String name,int age,int score){
        this.name=name;
        this.age=age;
        this.score=score;
    }
}
class Parent{
    public Student stu;
    public Parent(Student stu){
        this.stu=stu;
    }
}
public class test1{
    public static void main(String[] args) {
        Student stu=new Student("abc",100,19);
        Parent p=new Parent(stu);
        System.out.println(p.stu.name);
        System.out.println(p.stu.age);//protected同一个包类可以访问，若Parent与Student不在同一个包则无法访问
    }
}

4.什么是重载?有什么作用？
重载，从简单说，**就是函数或者方法有相同的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者重载方法。**在Java中同一个类中的2个或2个以上的方法可以有同一个名字，只要它们的参数声明不同即可。这种情况下，该方法就被称为重载，这个过程称为方法重载.
1.方法重载的主要好处就是不用为了对不同的参数类型或参数个数，而写多个函数。多个函数用同一个名字，但参数表，即参数的个数或(和)数据类型可以不同，调用的时候，虽然方法名字相同，但根据参数表可以自动调用对应的函数。这样我们在调用的时候，就不需要记那么多的方法名称，而是知道了方法的功能就可以直接的给他传递不同的参数，编译器会明确的知道我们调用了哪一个方法。重载比if…else要优雅，减少了if…else部分的代码。
2. 重载的最直接作用是方便了程序员可以根据不同的参数个数，顺序，类型，自动匹配方法，减少写过个函数名或方法名的重复步骤。

package A;
class Student{
    public String name;
    protected int age;
    private int score;
    public Student(String name,int age,int score){
        this.name=name;
        this.age=age;
        this.score=score;
    }
    public void test(String name){
        System.out.println(name);
    }
    public int test(){
        System.out.println(age);
        return age;
    }
    public void test(String name,int age){
        System.out.println(name+" "+age);
    }
    public void test(int age,int socre){
        System.out.println(age+" "+score);
    }
}
public class test1{
    public static void main(String[] args) {
        Student stu=new Student("abc",19,120);
        stu.test();
        stu.test("zzz");
        stu.test("zzz",18);
        stu.test(18,100);

    }
}

5.什么是覆写？有什么作用？覆写父类方法的条件有哪些？
覆写是子类对父类方法的重新编写。
重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。
1.子类的访问修饰符权限应大于等于父类，不能变小，父类private方法子类不能访问，更谈不上覆写了。
2.子类的返回类型能够向上转型成为父类的返回类型，也就是返回类型是父类返回类型的子类。
3.异常也要能向上转型为父类的异常。
4.方法名，参数类型及个数必须一致
注意：覆写只能针对非静态，非final,非构造方法。
有了继承概念后对于this和super的使用一定要清楚：
1）this：表示先从本类查找，如果本类没有则查找父类；
2）super：表示不查找本类，而是直接查找父类；

package A;
class Parent{
    public String name;
    protected int age;
    private int score;
    public Parent(String name,int age,int score){
        this.name=name;
        this.age=age;
        this.score=score;
    }
    public void speak(){
        System.out.println(name+" "+age+" "+score);
    }
    private int getScore(){//私有方法不能覆写
        return score;
    }
    public Number getAge(){
        return age;
    }
    protected void test(){
        System.out.println("this is test");
    }
}
class Student extends Parent{
    public int value;
    public Student(String name,int age,int score,int value){
        super(name,age,score);
        this.value=value;
    }
    @Override
    public void speak(){
        System.out.println(name+" "+age+" "+value);
    }
    @Override
    public void test(){//权限可以增大,但不能缩小
        System.out.println("this is new test");
    }
    @Override
    public Integer getAge(){//返回类型必须相同或者是父类返回类型的子类
        return age;
    }
}
public class test1{
    public static void main(String[] args) {
        Student stu=new Student("abc",19,120,10);
        stu.speak();
        stu.test();
    }
}