面向对象第4天

小姜认真点
143 阅读5分钟

面向对象第4天：

精华笔记：

笔记：

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

    • 发生在父子类中，方法名相同，参数列表相同
    • 重写方法被调用时，看对象的类型-------------------------这是规定，记住就OK了
    • 重写需遵循"两同两小一大"原则：--------------------------了解即可，一般都是一模一样的
      • 两同：
        • 方法名相同
        • 参数列表相同
      • 两小：
        • 派生类方法的返回值类型小于或等于超类方法的
          • void和基本类型时，必须相等
          • 引用类型时，小于或等于
        • 派生类方法抛出的异常小于或等于超类方法的-------------------后期讲异常的时候才能讲
      • 一大：
        • 派生类方法的访问权限大于或等于超类方法的

  2. package和import：

    • package：声明包
      • 作用：避免类的命名冲突
      • 同包中的类不能同名，但不同包中的类可以同名
      • 类的全称：包名.类名
      • 建议：包名所有字母都小写，并且常常有层次结构
    • import：导入类
      • 同包中的类可以直接访问，但不同包中的类不能直接访问，若想访问：
        • 先import导入类，再访问类------建议
        • 类的全称-------------------------------太繁琐，不建议

  3. 访问控制修饰符：--------------------------保护数据的安全，实现封装，隐藏数据，暴露行为

    • public：公开的，任何类

    • private：私有的，本类

    • protected：受保护的，本类、派生类、同包类

    • 默认的：什么也不写，本类、同包类--------------------------------java不建议默认权限

      注意：

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

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

      3. 访问控制修饰符的访问权限由低到高依次为：private<默认的<protected<public

  4. static：静态的

    • 静态变量：

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

    • 静态方法：

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

    • 静态块：

      • 由static修饰

      • 属于类，在类被加载期间自动执行，一个类只被加载一次，所以静态块也只执行一次

      • 何时用：初始化/加载静态资源(图片、音频、视频等)

笔记：

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

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

    • 重写方法被调用时，看对象的类型-------------------------这是规定，记住就OK了

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

    • 重写需遵循"两同两小一大"原则：--------------------------了解即可，一般都是一模一样的

      • 两同：
        • 方法名相同
        • 参数列表相同
      • 两小：
        • 派生类方法的返回值类型小于或等于超类方法的
          • void和基本类型时，必须相等
          • 引用类型时，小于或等于
        • 派生类方法抛出的异常小于或等于超类方法的-------------------后期讲异常的时候才能讲
      • 一大：
        • 派生类方法的访问权限大于或等于超类方法的
      public class OverrideDemo {
    public static void main(String[] args) {

    }
}

//超类大，派生类小
class Aoo{
    void show(){}
    double test(){ return 0.0; }
    Boo say(){ return null; }
    Aoo sayHi(){ return null; }
}
class Boo {
    //int show(){ return 1; } //编译错误，void时必须相等
    //int test(){ return 0; } //编译错误，基本类型时必须相等
    //Aoo say(){ return null; } //编译错误，引用类型时必须小于或等于
    Boo sayHi(){ return null; } //正确，Boo小于Aoo
}

  2. package和import：

    • package：声明包
      • 作用：避免类的命名冲突
      • 同包中的类不能同名，但不同包中的类可以同名
      • 类的全称：包名.类名
      • 建议：包名所有字母都小写，并且常常有层次结构
    • import：导入类
      • 同包中的类可以直接访问，但不同包中的类不能直接访问，若想访问：
        • 先import导入类，再访问类------建议
        • 类的全称-------------------------------太繁琐，不建议

  3. 访问控制修饰符：--------------------------保护数据的安全，实现封装，隐藏数据，暴露行为

    • public：公开的，任何类

    • private：私有的，本类

    • protected：受保护的，本类、派生类、同包类

    • 默认的：什么也不写，本类、同包类--------------------------------java不建议默认权限

      注意：

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

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

      3. 访问控制修饰符的访问权限由低到高依次为：private<默认的<protected<public

      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 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; //编译错误
    }
}

package ooday04_vis;
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修饰

      • 属于类，存储在方法区中，只有一份

      • 常常通过类名点来访问

      • 何时用：所有对象所共享的数据(图片、音频、视频等)

        package ooday04;
//static的演示
public class StaticDemo {
    public static void main(String[] args) {
        Foo o1 = new Foo();
        o1.show();
        Foo o2 = new Foo();
        o2.show();
        Foo o3 = new Foo();
        o3.show();
        System.out.println(Foo.b); //常常通过类名点来访问
    }
}
//演示静态变量
class Foo{
    int a; //实例变量
    static int b; //静态变量
    Foo(){
        a++;      //今天晚上的晚课，暂停一次
        b++;
    }
    void show(){
        System.out.println("a="+a+",b="+b);
    }
}

    • 静态方法：

      • 由static修饰

      • 属于类，存储在方法区中，只有一份

      • 常常通过类名点来访问

      • 静态方法中没有隐式this传递，所以不能直接访问实例成员

      • 何时用：方法的操作与对象无关

        package ooday04;
//static的演示
public class StaticDemo {
    public static void main(String[] args) {
        int num = Hoo.plus(5,6); //常常通过类名点来访问
    }
}

//演示静态方法何时用
class Hoo{
    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;
    }
}

//演示静态方法
class Goo{
    int a; //实例变量(通过对象来访问)
    static int b; //静态变量(通过类名来访问)
    void show(){ //有隐式this
        System.out.println(this.a);
        System.out.println(Goo.b);
    }
    static void test(){ //没有隐式this
        //静态方法中没有隐式this传递
        //没有this就意味着没有对象
        //而实例变量a必须通过对象来访问
        //所以如下语句发生编译错误
        //System.out.println(a); //编译错误
        System.out.println(Goo.b);
    }
}

    • 静态块：

      • 由static修饰

      • 属于类，在类被加载期间自动执行，一个类只被加载一次，所以静态块也只执行一次

      • 何时用：初始化/加载静态资源(图片、音频、视频等)

        package ooday04;
//static的演示
public class StaticDemo {
    public static void main(String[] args) {
        Ioo o4 = new Ioo();
        Ioo o5 = new Ioo();
        Ioo o6 = new Ioo();
    }
}

//演示静态块
class Ioo{
    static {
        System.out.println("静态块");
    }
    Ioo(){
        System.out.println("构造方法");
    }
}

补充：

  1. 数据(成员变量)私有化(private)，行为(方法)大部分都公开化(public)

  2. 成员变量分两种：

    • 实例变量：没有static修饰，属于对象的，存储在堆中，有几个对象就有几份，通过引用名(对象)打点来访问

      静态变量：有static修饰，属于类的，存储在方法区中，只有一份，通过类名打点来访问

  3. 内存管理：由JVM管理的

    • 堆：new出来的对象(包括实例变量、数组的元素)
    • 栈：局部变量(包括方法的参数)
    • 方法区：.class字节码文件(包括静态变量、所有方法)

  4. 明日单词：

    1)graphics:图像/画笔
2)PI:圆周率
3)count:数量
4)abstract:抽象的
5)live:活着的
6)dead:死了的
7)state:状态
8)is:是
9)paint:画
10)final:最终的
avatar
文章
阅读
粉丝