方法的重写、package、import、访问控制修饰符、static

一、方法的重写(override/overiding):重新写、覆盖

 1.发生在父子类中，方法名相同，参数列表相同

 2.重写方法被调用时，看对象的类型---------------------这是规定，记住就可以了

class 餐馆{
    void 做餐(){ 做中餐 }
}
//1)我还是想做中餐-------------------不需要重写
class Aoo extends 餐馆{
}
//2)我想改做西餐---------------------需要重写
class Boo extends 餐馆{
    void 做餐(){ 做西餐 }
}
//3)我想在中餐基础之上加入西餐---------需要重写
class Coo extends 餐馆{
    void 做餐(){
        super.做餐();---------------------上一章的super.方法名可以这样用
        做西餐
    }
}

 3.遵循"两同两小一大"原则：-------------了解即可，一般都是一模一样的

  (1)两同:

     -方法名相同

     -参数列表相同

  (2)两小:

     -派生类方法的返回值类型小于或等于超类方法的

      ——void和基本类型时，必须相等

      ——引用类型时，小于或等于

//超类大，派生类小
class Aoo{ //大
    void show(){}
    double test(){ return 0.0; }    //看一看
    Boo say(){ return null; }
    Aoo sayHi(){ return null; }
}
class Boo extedns Aoo{ //小
    //int show(){ return 1; } //编译错误，void时必须相同
    //int test(){ return 0; } //编译错误，基本类型时必须相同
    //Aoo say(){ return null; } //编译错误，引用类型时必须小于或等于
    Boo sayHi(){ return null; } //正确
}

     -派生类方法抛出的异常小于或等于超类方法的---------------API异常时讲

  (3)一大:

     -派生类方法的访问权限大于或等于超类方法的---------------访问控制修饰符时讲

二、package和import：

 1.package：声明包

  (1)作用：避免类的命名冲突

  (2)同包中的类不能同名，但不同包中的类可以同名

  (3)类的全称：包名.类名

  (4)包名所有字母都小写，并且常常有层次结构

 2.import：导入类

  (1)同包中的类可以直接访问，但不同包中的类不能直接访问，若想访问：

    ——先import导入类再访问----------建议

    ——类的全称-----------------------------太繁琐，不建议

三、访问控制修饰符：-------------保护数据的安全

 1.public：公开的，任何类

 2.private：私有的，本类

 3.protected：受保护的，本类、派生类、同包类------------用得很少

 4.默认的：什么也不写，本类、同包类--------------------------不建议默认访问权限

注意：

1. 访问权限由低到高依次为：private<默认的<protected<public
2. 类的访问权限只能是public或默认的，而类中成员的访问权限如上4种都可以

package ooday04;
public class Coo {
    public int a;    //任何类
    protected int b; //本类、派生类、同包类
    int c;           //本类、同包类
    private int d;   //本类

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


class Doo{ //-------------------演示private
    void show(){
        Coo o = new Coo();
        o.a = 1;
        o.b = 2;
        o.c = 3;
        //o.d = 4; //编译错误
    }
}
--------------------------------------------------------------------------
package ooday04_vis;
import ooday04.Coo;
public class Eoo { //演示同包的
    void show(){
        Coo o = new Coo();
        o.a = 1;
        //o.b = 2; //编译错误
        //o.c = 3; //编译错误
        //o.d = 4; //编译错误
    }
}

class Foo extends Coo{ //跨包继承-----演示protected
    void show(){
        a = 1;
        b = 2;
        //c = 3; //编译错误
        //d = 4; //编译错误
    }
}

四、static：静态的

 1.静态变量：

  (1)由static修饰

  (2)属于类，存储在方法区中，只有一份

  (3)常常通过类名点来访问

  (4)何时用：所有对象所共享的数据(图片、音频、视频等)

public class StaticDemo {
    public static void main(String[] args) {
        Goo o1 = new Goo();
        o1.show();
        Goo o2 = new Goo();
        o2.show();
        Goo o3 = new Goo();
        o3.show();
        System.out.println(Goo.b); //常常通过类名点来访问
    }
}

//演示静态变量
class Goo{
    int a; //实例变量
    static int b; //静态变量
    Goo(){
        a++;
        b++;
    }
    void show(){
        System.out.println("a="+a+",b="+b);
    }
}

 2.静态方法：

  (1)由static修饰

  (2)属于类，存储在方法区中，只有一份

  (3)常常通过类名点来访问

  (4)何时用：方法的操作与对象无关(不需要访问对象的属性或方法)

public class StaticDemo {
    public static void main(String[] args) {
        int a = Ioo.plus(5,6); //常常通过类名点来访问
    }
}

//演示静态方法
class Hoo{
    int a; //实例变量(由对象来访问)
    static int b; //静态变量(由类来访问)

    void show(){ //有隐式this
        System.out.println(this.a);
        System.out.println(Hoo.b);
    }
    static void test(){ //没有隐式this
        //静态方法中没有隐式this传递
        //没有this就意味着没有对象
        //而实例变量a是必须通过对象点来访问的
        //所以如下语句发生编译错误
        //System.out.println(a); //编译错误
        System.out.println(Hoo.b);
    }
}

//演示静态方法何时用:
class Ioo{
    int a; //实例变量(描述对象的属性)

    //show()中访问了对象的属性a，意味着show方法的操作与对象有关，不能设计为静态方法
    void show(){
        System.out.println(a);
    }
    //plus()中并没有访问对象的属性/行为，意味着plus的操作与对象无关，可以设计为静态方法
    static int plus(int num1,int num2){
        int num = num1+num2;
        return num;
    }

}

 3.静态块：

  (1)由static修饰

  (2)属于类，在类被加载期间自动执行，一个类只被加载一次，所以静态块也只执行一次

  (3)何时用：加载/初始化静态资源(图片、音频、视频等)

public class StaticDemo {
    public static void main(String[] args) {
        Joo o4 = new Joo();
        Joo o5 = new Joo();
        Joo o6 = new Joo();
    }
}

//演示静态块
class Joo{
    static{
        System.out.println("静态块");
    }
    Joo(){
        System.out.println("构造方法");
    }
}

补充

 1.数据(成员变量)私有化(private)，行为(方法)大部分公开化(public)

 2.成员变量的分类：

  (1)实例变量：没有static修饰，属于对象的，存储在堆中，有几个对象就有几份，通过对象/引用打点来访问

  (2)静态变量：有static修饰，属于类的，存储在方法区中，只有一份，通过类名点来访问

 3.内存管理：由JVM来管理的

  (1)堆：new出来的对象(包含实例变量、数组的元素)

  (2)栈：局部变量(包括方法的参数)

  (3)方法区：.class字节码文件(包括静态变量、所有方法)

 4.给实例变量初始化建议写在构造方法中，给静态变量初始化建议写在静态块中

 5.明日单词：

1)graphics:图像/画笔
2)PI:圆周率
3)count:数量
4)abstract:抽象的
5)live:活着的
6)dead:死了的
7)state:状态
8)is:是
9)paint:画
10)final:最终的