【java基础面向对象】方法的重写、 package和import包、访问控制修饰符,static,final,static final,抽象方法

1. 方法的重写(override/overriding)：重新写、覆盖

2. package和import：

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

4. static：静态的

5. final：最终的、不可改变的---------------------应用率低

6. static final常量：应用率高

7. 抽象方法：

8. 抽象类：

1. 方法的重写(override/overriding)：重新写、覆盖

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

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

class 餐馆{

        void 做餐(){ 做中餐 }

}

//1)我还是想做中餐---------------不需要重写

class Aoo extends 餐馆{

}

//2)我想改做西餐-----------------需要重写

class Aoo extends 餐馆{

        void 做餐(){ 做西餐 }

}

//3)我想在中餐基础之上加入西餐------需要重写(先super中餐，再加入西餐)

class Aoo extends 餐馆{

        void 做餐(){

super.做餐();

        做西餐

        }

}

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

两同：

方法名相同

参数列表相同

两小：

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

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

引用类型时，小于或等于

//超类大，派生类小

class Aoo{ //超类(大)

        void show(){}

        double test(){ return 0.0; }

        Boo sayHi(){ return null; }

        Aoo say(){ return null; }

}

class Boo extends Aoo{ //派生类(小)

        //int show(){ return 1; } //编译错误，void时必须相等

        //int test(){ return 0; } //编译错误，基本类型时必须相等

        //Boo sayHi(){ return null; } //编译错误，引用类型时必须小于

        或等于

        Boo say(){ return null; } //正确，小于或等于

}

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

一大：

派生类方法的访问权限大于或等于超类方法的

2. package和import：

package：声明包

作用：避免类的命名冲突

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

类的全称：包名.类名

建议：包名所有字母都小写，包名常常有层次结构

import：导入类

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

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

类的全称---------------------------------太繁琐、不建议

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

public：公开的，任何类

private：私有的，本类

protected：受保护的，本类、派生类、同包类------------------------应用率低

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

说明：

1. 类的访问权限，只能是public或默认的。而类中成员的访问权限，如上4种都可

以。

2. 访问权限由低到高依次为：private<默认的<protected<public

//访问控制修饰符的演示

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; //编译错误

        }

}

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; //编译错误

        }

}

4. static：静态的

静态变量：

由static修饰属于类，存储在方法区中，只有一份

常常通过类名点来访问

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

//演示静态变量

class Goo{

int a;

static int b;

Goo(){

        a++;

        b++;

}

void show(){

System.out.println("a="+a+",b="+b);

        }

}

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); //常常通过类名点来访问

        }

}

静态方法：

由static修饰

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

常常通过类名点来访问

静态方法中没有隐式this传递，不能直接访问实例成员

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

//演示静态方法

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()中访问了对象的属性，意味着show()方法与对象有关，不能设计为静态方

        法

        void show(){

        System.out.println(a);

}

//在plus()中没有访问对象的属性，意味着plus()方法与对象无关，可以设计为静态

方法

        static int plus(int num1,int num2){

        int num = num1+num2;

        return num;

        }

}

public class StaticDemo {

        public static void main(String[] args) {

        Hoo.test(); //常常通过类名点来访问

        }

}

静态块：

由static修饰

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

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

//演示静态块

class Joo{

        static{

        System.out.println("静态块");

        }

        Joo(){

        System.out.println("构造方法");

        }

}

        public class StaticDemo {

                public static void main(String[] args) {

                Joo o4 = new Joo();

                Joo o5 = new Joo();

                Joo o6 = new Joo();

        }

}

5. final：最终的、不可改变的---------------------应用率低

修饰变量：变量不能被改变

class Aoo{
  final int a = 5;
  void show(){
    //a = 55; //编译错误，final的变量不能被改变
}
}

修饰方法：方法不能被重写

class Boo{
  final void show(){ }
  void test(){ }
}
class Coo extends Boo{
  //void show(){ } //编译错误，final的方法不能被重写
  void test(){ }
}

修饰类：类不能被继承

final class Doo{}
//class Eoo extends Doo{} //编译错误，final的类不能被继承
class Foo{}
final class Goo extends Foo{} //正确，不能当老爸，但能当儿子

6. static final常量：应用率高

必须声明同时初始化

常常通过类名点来访问，不能被改变

建议：常量所有字母都大写，多个单词之间用_分隔

编译器在编译时会将常量直接替换为具体的数，效率高

何时用：数据永远不变，并且经常使用

public class StaticFinalDemo {

public static void main(String[] args) {
    System.out.println(Hoo.PI); //常常通过类名点来访问
    //Hoo.PI = 3.1415926; //编译错误，常量不能被改变
    //1)加载Ioo.class到方法区中
    //2)静态变量num一并存储在方法区中
    //3)到方法区中获取num的值并输出
    System.out.println(Ioo.num);
    //编译器在编译时会将常量直接替换为具体的值，效率高
    //相当于System.out.println(5);
    System.out.println(Ioo.COUNT);
}
}

class Ioo{
  public static int num = 5; //静态变量
  public static final int COUNT = 5; //常量
}
class Hoo{
  public static final double PI = 3.14159;
  //public static final int NUM; //编译错误，常量必须声明同时初始化
}

7. 抽象方法：

由abstract修饰

只有方法的定义，没有具体的实现(连{}都没有)

8. 抽象类：

由abstract修饰

包含抽象方法的类必须是抽象类

抽象类不能被实例化(new对象)

意味着画对象的行为为共有行为，所以设计在SeaObject超类中，

每个对象画的代码都是一样的，所以设计为普通方法

派生类：

重写抽象类中的所有抽象方法-----------变不完整为完整

也声明为抽象类------------------------------一般不这么做

抽象类的意义：

封装共有的属性和行为---------------------代码复用

为所有派生类提供统一的类型------------向上造型(代码复用)

可以包含抽象方法，为所有派生类提供统一的入口(向上造型后能点出来)，同时可以达到

强制必须重写的目的

抽象方法存在的意义是什么？
保证当发生向上造型时，通过超类的引用能点出来那个方法-----------保证能点出方法来
既然抽象方法的意义是保证能点出来，那为什么不设计为普通方法呢?

设计为普通方法，意味着派生类可以重写也可以不重写，但设计为抽象方法，则可以强
制派生类必须重写-----------强制派生类重写，可以达到统一的目的