Day16-面向对象抽象方法,抽象类,常量

Day16-面向对象第5天

精华笔记：

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

   • 修饰变量：变量不能被改变
   • 修饰方法：方法不能被重写
   • 修饰类：类不能被继承, 但是可以继承别人----------不能当老爸, 可以当儿子

   final int a = 5;
   class Aoo{ void Aoo{}    }
   

2. static final常量：应用率高 static修饰的一般都是公开的

   • 必须声明同时初始化, 常量一定是静态的

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

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

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

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

3. 抽象方法：

   • 由abstract修饰
   • 只有方法的定义，没有具体的实现(连{}都没有)(缺少方法体)

4. 抽象类：

   • 由abstract修饰

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

   • 抽象类不能被实例化(new对象)—单独存在没有意义

   • 抽象类是需要被继承的，派生类：

     • 重写抽象类中的所有抽象方法-----------变不完整为完整, 不需要加abstract
     • 抽象类不能实例化(new对象)------------因为类不完整, 不能new,但可以声明变量

     Seaobject o;
     Seaobject[] os;
     //SeaObject s = new Seaobject();//编译错误,不能new对象
     SeaObject[] s1 = new Seaobject[3];//不报错,任何类型都可以new数组
     

     • 也声明为抽象类------------------------------一般不这么做, 没有意义,不能new

   • 抽象类的意义：

     • 封装共有的属性和行为---------------------代码复用
     • 为所有派生类提供统一的类型------------向上造型(代码复用)
     • 可以包含抽象方法，为所有派生类提供统一的入口(向上造型后能点出来)，同时可以达到强制必须重写的目的

笔记：

1. 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{} //正确，不能当老爸，但能当儿子
     

2. 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; //编译错误，常量必须声明同时初始化
     }
     

3. 抽象方法：

   • 由abstract修饰
   • 只有方法的定义，没有具体的实现(连{}都没有)

4. 抽象类：

   • 由abstract修饰

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

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

   • 抽象类是需要被继承的，派生类：

     • 重写抽象类中的所有抽象方法-----------变不完整为完整
     • 也声明为抽象类------------------------------一般不这么做

   • 抽象类的意义：抽象类一定是作为超类, 单独没有意义

     • 封装共有的属性和行为---------------------代码复用
     • 为所有派生类提供统一的类型------------向上造型(代码复用)
     • 可以包含抽象方法，为所有派生类提供统一的入口(向上造型后能点出来)，同时可以达到强制必须重写的目的

     abstract class Seaobject{
         int width,height,x,y,speed;
         abstract void move();
     }
     //new Seaobject();//编译错误,没有意义
     
     class observesubmarmine extends SeaObject{//抽象类一定要继承
         void move{//注意重写不需要absract
             
         }
     }
     class Mine extends SeaObject{
         void move{
             
         }
     }
     

补充：

1. 设计规则：

   1.1 将派生类所共有的属性和行为，抽到超类中---------------------抽共性

   1.2. 若派生类的行为/代码都一样，设计为普通方法(修饰词,返回值类型,方法名(参数){方法体})

   若派生类的行为/代码不一样，设计为抽象方法(含abstract+没有方法体, ";"结尾, 需要强制重写)
   写抽象方法同时类必须抽象,重写时候不需要关键字abstract

   1.3. 方法有无返回值类型
   所得的数据看后期用不用,需不需要结果.需要-----则写对应的返回值类型
   若直接调用,不需要后续继续操作----------则不需要返回值类型

   1.4. 方法中是否需要参数
   看数据能够不能写死,写死的—没有参数
   写活的-------------------------需要写参数

   1.5方法的访问修饰词
   对象的属性/数据一般都是用private
   对象的方法/行为一般都是用public

2. 抽象方法/抽象类的疑问：

   • 抽象方法存在的意义是什么？
     • 保证当发生向上造型时，通过超类的引用能点出来那个方法-----------保证能点出方法来
   • 既然抽象方法的意义是保证能点出来，那为什么不设计为普通方法呢?
     • 设计为普通方法，意味着派生类可以重写也可以不重写，但设计为抽象方法，则可以强制派生类必须重写-----------强制派生类重写，可以达到统一的目的

3. 画对象带数：先找main

   • 当创建(new)World对象时，就会分配World类中的实例变量(ship,submarines,mines,bombs)，对象的数据(width/height/x/y/speed/life)都赋好值了

   • frame.setVisible(true)时会自动调用paint()方法，在paint()中：当第1次用到Images类时，会将Images.class加载到方法区中，同时将那一堆静态图片分配到方法区中，同时自动执行静态块给图片赋值

   • ship.paintImage(g)时会去调用SeaObject中的paintImage()方法，方法中的this指的就是战舰ship，方法中先判断战舰是否是活着的，若活着则获取战舰的图片，用画笔画到战舰的x和y坐标上。

     submarines[i].paintImage(g)时会去调用SeaObject中的paintImage()方法，假设submarines[i]为侦察潜艇对象，则方法中的this指的就是侦察潜艇，方法中判断侦察潜艇是否是活着的，若活着则获取侦察潜艇的图片，用画笔画到侦察潜艇的x和y坐标上。假设submarines[i]为鱼雷潜艇对象，则…

注意点

1.重写(override)和重载(overload)的区别

1)重写一定发生在父子类中,方法名好和参数列表相同

2)重载发生在同一类中,方法名相同,参数列表不同

2. 实例变量和静态变量的区别

---------都属于成员变量

1)实例变量: 属于对象, 在创建对象时候存储在内存的堆中,创建了多少个对象, 则实例变量就会在内存堆中存在多少份, 需要通过引用变量打点来访问

2)静态变量: 属于类中, 在类被加载时存储在内存方法区中,无论创建了多少个对象, 静态变量在内存中都只有一份,

常常通过类名打点来访问

3.重载的特殊形式

class Aoo{
    void show(){}
}
class Boo extends Aoo{//在此类中发生了show()的重载
    void show(String name){}
}

4.final 可以修饰成员变量也可以修饰局部变量

1)修饰成员变量时,只能声明同时初始化或者在构造方法中初始化

2)修饰成员变量时候,只要在使用前面给值即可

class Test{ // 方法外成员变量
    final int a = 5;//成员变量声明并初始化
    final int b ;//或者成员变量先声明
    Test{
        b = 6;//并构造方法值初始化
    }
    void show(){//方法内局部变量
        final int c;//局部变量可以声明不初始化
        final int d =1;
        system.out.println(d);//局部变量在使用前声明并初始化
    }