java面向对象第四天

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

   • 发生在父子类中，方法名相同，参数列表相同
   • 重写方法被调用时，看对象的类型------------这是规定，记住就OK

   当派生类觉得超类的行为不够好时，可以重写

   我继承了一个中餐馆
   class Aoo{
       void do(){
           做中餐
       }
   }
   A:我还是想做中餐------------不需要重写
       class Boo extends Aoo{
       }
   B:我想改做西餐--------------需要重写
       class Boo extends Aoo{
           void do(){
               做西餐
           }
       }
   C:我想在中餐基础之上加西餐-----需要重写(先super中餐，再加入西餐)
       class Boo extends Aoo{
           void do(){
               super.do();
               做西餐
           }
       }

2. 重写与重载的区别：重点(常见的面试题)

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

     一般用于在派生类中修改超类的方法

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

     是完全不同的方法，只是方法名相同而已

3. package和import：

   • package：声明包

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

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

   • import：导入类

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

       • 先import导入类，再访问类----------建议
       • 类的全称-----------------------------------太繁琐，不建议

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

4. 访问控制修饰符：

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

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

   1. 类的访问权限只能是public或默认的

   1. 类中成员的访问权限如上四种都可以

   //封装的意义
   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 ooday04;
   //演示访问控制修饰符
   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 ooday04_vis;
   import ooday04.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; //编译错误
       }
   }

5. static：静态的

   • 静态变量：

     • 由static修饰
     • 属于类，存储在方法区中，只有一份
     • 常常通过类名点来访问
     • 何时用：所有对象所共享的数据(图片、音频、视频等)

     public class StaticDemo {
         public static void main(String[] args) {
             Eoo o1 = new Eoo();
             o1.show();
             Eoo o2 = new Eoo();
             o2.show();
             Eoo o3 = new Eoo();
             o3.show();
             System.out.println(Eoo.b); //常常通过类名点来访问
         }
     }
     
     class Eoo{ //演示静态变量
         int a;
         static int b;
         Eoo(){
             a++;
             b++;
         }
         void show(){
             System.out.println("a="+a+",b="+b);
         }
     }

   • 静态方法：

     • 由static修饰
     • 属于类，存储在方法区中，只有一份
     • 常常通过类名点来访问
     • 静态方法没有隐式this传递，所以不能直接访问实例成员
     • 何时用：方法的操作与对象无关

     //static的演示
     public class StaticDemo {
         public static void main(String[] args) {
             Goo.plus(4,6);
         }
     }
     
     //演示静态方法
     class Foo{
         int a; //实例变量(由对象来访问)
         static int b; //静态变量(由类名来访问)
     
         void show(){ //有隐式this
             System.out.println(this.a);
             System.out.println(Foo.b);
         }
         static void test(){
             //静态方法中没有隐式this传递
             //没有this就意味着没有对象
             //而实例变量a是必须由对象来访问的
             //所以下面的语句发生编译错误
             //System.out.println(a); //编译错误
     
             System.out.println(Eoo.b);
         }
     }
     
     //演示静态方法何时用
     class Goo{
         int a; //对象的属性
         //方法中用到了对象的属性a，意味着show()的操作与对象是有关的，不能做成静态方法
         void show(){
             System.out.println(a);
         }
         //方法中没有用到对象的属性和行为，意味着plus()的操作与对象是无关的，可以做成静态方法
         static void plus(int num1,int num2){
             int num = num1+num2;
             System.out.println(num);
         }
     }

   • 静态块：

     • 由static修饰
     • 属于类，在类被加载期间自动执行，一个类只被加载一次，所以静态块也只执行一次
     • 何时用：初始化/加载静态资源(图片、音频、视频等)

     public class StaticDemo {
         public static void main(String[] args) {
             Hoo o4 = new Hoo();
             Hoo o5 = new Hoo();
             Hoo o6 = new Hoo();
         }
     }
     //演示静态块
     class Hoo{
         static {
             System.out.println("静态块");
         }
         Hoo(){
             System.out.println("构造方法");
         }
     }