【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 超类中，

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

派生类：

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

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

抽象类的意义：

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

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

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

强制必须重写的目的

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

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