oop面向对第五六天：访问修饰符、最终、静态(静态变量/静态方法/静态块{})、static final、成员/匿名内部类(隐式对象:this/super/外部类名.this)、抽象类abstract

面向对象第五天：

回顾：

1.向上造型：
超类型的引用指向派生类的对象
能点出来什么，看引用的类型-----------规定

2. 方法的重写(override)：重新写、覆盖

• 发生在父子类中，方法名相同，参数列表相同
• 重写方法被调用时，看对象的类型

派生类觉得超类的行为不够好，想修改需要重写

3. 重写与重载的区别：

• 重写：发生在父子类中，方法名相同，参数列表相同
• 重载：发生在同一类中，方法名相同，参数列表不同

笔记：

1、package和import：

• package：声明包

  • 作用：避免类的命名冲突
  • 同包中的类不能同名，不同包中的类可以同名
  • 类的全称：包名.类名，包名常常有层次结构
  • 建议：包名所有字母都小写

  说明：package声明包必须位于第一行

• import：导入类

  • 同包中的类可以直接访问，不同包的类不能直接访问，若想访问：
    • 先import导入类，再访问类----------建议
    • 类的全称-----------------------------------太繁琐，不建议

  说明：import导入类必须位于声明包的下一行

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

封装的意义：隐藏一些东西，暴露一些东西，来保护数据的安全

---------权限从大到写排列：

• public：公开的，任何类
• protected：受保护的，本类、派生类、同包类
• 默认的：什么也不写，本类、同包类
• private：私有的，本类

-数据(成员变量)私有化private，行为(方法)公开化

说明：
- 类的访问权限只能是public或默认的
- 类和接口和抽象类的访问权限只能是public或默认的，类中成员的访问权限4种都可以
- 访问权限由高到低依次为：public>protected>默认的>private

//封装的意义
   class Card{
   
       private String cardId;
       private String cardPwd;
       private double balance;
       
       public boolean payMoney(double money){
    //支付金额
           if(balance>=money){
   
               balance-=money;
               return true;
           }else{
   
               return false;
           }
       }
       
       public boolean checkPwd(String pwd){
    //检测密码
           if(pwd与cardPwd相同){
   
               return true;
           }else{
   
               return false;
           }
       }
   }

 //访问权限范围:
package ooday05;
//访问控制修饰符的演示
public class Aoo {
   
    public int a;    //任何类
    protected int b; //本类、派生类、同包类
    int c;           //本类、同包类
    private int d;   //本类

    void show(){
   
        a = 1;
        b = 2;
        c = 3;
        d = 4;
    }
}
class Boo{
    //--------------------演示private
    void show(){
   
        Aoo o = new Aoo();
        o.a = 1;
        o.b = 2;
        o.c = 3;
        //o.d = 4; //编译错误
    }
}

package ooday05_vis;
import ooday05.Aoo;
public class Coo {
    //----------------演示同包的
    void show(){
   
        Aoo o = new Aoo();
        o.a = 1;
        //o.b = 2; //编译错误
        //o.c = 3; //编译错误
        //o.d = 4; //编译错误
    }
}
class Doo extends Aoo{
    //跨包继承----------演示protected
    void show(){
   
        a = 1;
        b = 2;
        //c = 3; //编译错误
        //d = 4; //编译错误
    }
}

3、final：最终的，不可改变的-----------单独应用几率低

• 1、修饰变量：变量不能被改变
• 2、修饰方法：方法不能被重写
• 3、修饰类：类不能被继承

package oopday9.day05.Final;
/**
 * 《演示final修饰变量》：
 * 1、修饰变量：变量不能被改变
 * 2、修饰方法：方法不能被重写
 * 3、修饰类：类不能被继承
 *
 */
/* 1、修饰变量：变量不能被改变 */
public class Aoo {
   
    final int num = 5;
    void show() {
   
        //num = 55; //编译错误，——————————————final的变量不能被改变
    }
}


/* 2、修饰方法：方法不能被重写 */
class Boo{
   
    final void show(){
   }
}

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


/* 3、修饰类：类不能被继承 */
final class Doo{