RE:JAVA学习-深入继承+访问控制

一.方法的重写(Override):重新写 覆盖
1>发生在父子类中,方法名称相同,参数列表相同,方法体不同
2>重写方法被调用时,看对象的类型

->两同两小一大:   方法名称相同,参数列表相同
            子类方法的返回值类型小于或等于父类方法的
                void和基本类型时,必须相等
                引用类型时,小于或等于
            子类抛出的异常小于或等于父类的
            子类方法的访问权限大于或等于父类的

public class Eoo  {
    public static void main(String[] args) {
        Aoo ab=new Boo();//Aoo的引用指向Boo的对象 向上造型
        ab.show();//向上造型时,调用父类和子类共有的方法时,则调用子类重写的方法
//      ab.bshow();//但子类特有的方法不能调用
        Boo b=new Boo();
        b.aShow();//子类可以调用父类的方法
        b.show();
        Aoo a=new Aoo();
        a.show();
//      a.bShow();//父类不能调用子类的方法
    }
}

class Aoo {
    public void show(){
        System.out.println("父类Aoo的show方法");
    }
    public void aShow(){
        System.out.println("父类Aoo的aShow方法");
    }
}

class Boo extends Aoo{
    public void show(){
        System.out.println("子类Boo的show方法");
    }
    public void bShow(){
        System.out.println("子类Boo特有的bShow方法");
    }
}

二.重写与重载的区别 ————–常见面试题
1>重写(override):
1.1>发生在父子类中,方法名称相同,参数列表相同,方法体不同
1.2>遵循”运行期”绑定,根据对象的类型来调用方法 (看对象)
2>重载(overload):
2.1>发生在一个类中,方法名称相同,参数列表不同,方法体不同
2.2>遵循”编译器”绑定,根据引用的类型来绑定方法 (看引用)
三.package和import
package: org.apache.commons.lang.StringUtils 域名反写.项目名称.模块名称.类名
1>作用:避免类的命名冲突
2>包名可以有层次结构,类的全称:包名,类名
3>同包中的类不能同名,但是不同1包中的类时可以同名的
4>建议:包名所有字母都小写
import:
1>同包中的类可以直接访问
不同包中的类是不能直接访问的,想访问有两种方式:
1.1)先import再使用类———建议
1.2)类的全称—————–太繁琐，不建议
四.访问控制修饰符
访问修饰符 访问权限

1>public    公共的     任何类
2>protected     受保护的    本类、子类、同包类
3> 什么也不写    默认的     本类、同包类
4>private   私有的     本类

类的访问修饰可以是public和默认的
类中成员的访问修饰如上4种都可以
(非同包例子可新建包自行尝试)

public class Foo {
    public int a;   //任何类
    protected int b;//本类 子类 同包类
    int c;  //本类 同包类
    private int d;  //本类

    void show(){
        a=1;
        b=2;
        c=3;
        d=4;
    }

}

class Goo{
    void show(){
        Foo o=new Foo();
        o.a=1;
        o.b=2;
        o.c=3;
//      o.d=4;
    }
}

五.static:静态的
成员变量,分两种:
1>实例变量:没有static修饰,存储在堆中,有几个对象就有几份
对象 点 来访问
2>静态变量:由static修饰,属于类的,存储在方法区,只有一份
类名 点 来访问
1>静态变量:
1.1>由static修饰的
1.2>属于类,存储在方法区中,只有一份
1.3>常常通过类名 点 来访问(对象 点 也可访问-不建议使用)
1.4>何时用:所有对象所共享的数据(图片 音频 视频等)
2>静态方法:
2.1>由static修饰
2.2>属于类的,存储在方法区,只有一份
2.3>常常通过类名 点来访问
2.4>静态方法没有隐式的this传递 (没有this 意味着没有对象 实例成员必须通过对象 点来访问 所以静态方法中不能访问实例成员)
静态方法中不能直接访问实例成员
2.5>何时用:方法的操作仅与参数相关而与对象无关
3>静态块:
3.1>由static修饰
3.2>属于类的,在类被加载期间自动执行的,
因为类只被加载一次,所以静态块也只执行一次
3.3>何时用:加载/初始化静态资源(图片 音频 视频等)

public class StaticDemo {
    public static void main(String[] arg){
        Qoo q=new Qoo();
        Roo r=new Roo();
        r.ma();
        Joo j1=new Joo();
        j1.show();
        Joo j2=new Joo();
        j2.show();
    }
}

class Joo{
    int a;
    static int b;
    Joo(){
        a++;
        b++;
    }
    void show(){
        System.out.println("a="+a);
        System.out.println("b="+b);
    }
}

class Roo{
    public static void ma(){
        System.out.println(Qoo.Num);
    }
}

class Qoo{
    public static final int Num=100;

    static{
        System.out.println("static");
    }
    Qoo(){
        System.out.println("gouzao");
    }
}

六.final:最终的,不可改变的
两种初始化:
声明同时初始化
构造函数中初始化
1>修饰变量:变量不能被改变
2>修饰方法:方法不能被重写
3>修饰类:类不能被继承

public class FinalDemo {

    public static void main(String[] args) {

    }
}

class Ooo {
    final void show(){

    }
}

final class Poo extends Ooo{

//  void show(){
//      
//  }
}

class Moo{
    final int a=5;
    final int b;
    Moo(){
        b=6;
    }
    void show(){
        final int c;
//      a=6;
    }
}