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("构造方法");
          }
      }

上一篇:关于WPF的退出


下一篇:jquery学习之1.4-内容过滤器学习