Day09面向对象3 static 静态/构造/局部代码块之间的关系、final的3作用、面向对象之多态

于 2021-06-09 18:02:25 发布
阅读量111 收藏
点赞数
文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_58580280/article/details/117750899
版权

***Debug操作***

 

package cn.tedu.oopextends;
/**本类用于Debug的学习
 * 1.我们可以在目标码前面，符号后面添加断点（红点），再按一次取消断点
 * 2.Debug断点调试的时候，需要以Debug."TestDebug.main()"的方式启动
 * 3.弹出来的窗口有两个：
 * Debugger：这个是Debug模式用于查看执行情况，比如变量当前值的窗口
 * Console--这个是我们之前常用的控制台，会显示程序执行的效果
 * 4.按F8进行下一步，想结束Debug就按左边红色方块按钮结束程序
 * 另外注意：Debug只会在断点处停下来，不打断点的位置不会停，要学会合理设置断点的设置*/
public class TestDebug {
    public static void main(String[] args) {
        for(int i =1;i<=10;i++){
            System.out.println(i);
        }
    }
}

1.静态  static

  1. static是关键字
  2. 可以修饰成员变量和方法，被修饰的资源就是静态资源
  3. 静态资源优先于对象加载，随着类的加载而加载，只加载一次，就会一直存在，不再开辟新空间, 直到类消失才一起消失
  4. 被静态修饰的资源可以通过类名直接调用
  5. 静态资源全局共享（被所有对象共享），值只有一份
  6. 不能在静态代码块中使用this或者super

1.1练习：static入门案例

package cn.tedu.oopstatic;
/**本类用于测试静态的入门案例*/
public class TestStatic1 {
    public static void main(String[] args) {
        /**3.静态资源可通过类名直接直接调用，无需创建对象
         * 4.静态资源优先于对象加载的，随着类的加载而加载
         *   比对象优先加载到内存，没对象时也可以通过类名进行直接调用*/
        System.out.println(Student.name);
        Student.speak();
        //4.创建Student类的对象并进行测试
        Student s= new Student();
        Student s1= new Student();
        System.out.println(s.name);
        s.study();
        //6.测试给属性name赋值
        s.name = "小乔";
        System.out.println(s1.name);//属性值改之前不影响，改之后全部对象都会影响
        s1.name = "黄桃罐头";
        /**5.静态资源可被全局所有对象（new）共享，值只有一份*/
        System.out.println(Student.name);
        System.out.println(s.name);
        System.out.println(s1.name);

    }
}
//1.通过抽象封装一个学生类
class Student{
    //2.创建属性--成员变量--有默认值，无需手动初始化
    /**1.可以通过static将普通资源修饰成静态资源
     * 2.static可以修饰成员变量和普通方法，一般写在修饰符的后面*/
    //5.1将成员变量name修饰成静态
    static String name;//姓名
    int sno;//学号

    //3.创建行为--普通方法
    public void study(){
        System.out.println("我一点都不想过端午，满脑子都是学java~~");
    }
    //5.2将speak方法修饰成静态
    public static void speak(){
        System.out.println("会就要大声说出来！！！");
    }
}

1.2练习：测试静态资源与普通资源的调用关系

  调用关系：静态资源只能调用静态资源

   非静态资源看调用静态资源，也可调用非静态资源

package cn.tedu.oopstatic;
/***本类用于测试静态资源与普通资源的调用关系*/
public class TestStatic2 {
}
//1.首先封装一个老师类
class Teacher{
    //2.定义普通资源
    //2.1定义普通属性
    String name;
    //2.2定义普通方法
    public void teach(){
        /**1.普通资源能否调用静态资源？--可以！！！*/
        System.out.println(age);//普通资源可以调用静态属性
        eat();//普通资源可以调用静态方法
        System.out.println("正在授课ing~~");
    }
    //3.定义静态资源
    //3.1定义静态属性
    static int age;
    //3.2定义静态方法
    public static void eat(){
        /**2.静态资源能否调用普通资源？--不可以！！！*/
        //System.out.println(name);//静态资源不能调用非静态属性
        //teach();
        System.out.println("扶我起来，我还能吃！！！");
    }
    public static void sleep(){
        /**3.静态资源能否调用静态资源？--可以*/
        System.out.println(age);
        eat();//静态方法可以调用静态方法
        System.out.println("我是静态修饰方法");
    }
}

2.静态代码块、构造代码块、局部代码块

2.1静态代码块的格式：

静态资源随着类的加载而加载，并且只被加载一次，一般用于项目的初始化
特点: 被static修饰

2.2三种代码块的比较：

1.静态代码块：
   *格式：static{方法体}
   *位置：类里方法外
   *触发时机：静态代码块也是静态资源，随着类的加载而加载，优先于对象加载，并且只加载一                        次的资源
   *作用：用于专门完成一些需要第一时间就加载且加载一次的资源
2.构造代码块：
  *格式：{ }
  *位置：类里方法外
  *执行时机：创建对象时触发，优先构造方法执行
  *作用：用于提取所有构造方法的共性功能内容
3.局部代码块：
  *格式{ }
  *位置：普通方法里
  *执行时机：调用当前局部代码块所处的方法时才触发
  *作用：用来控制变量的作用范围，变量的作用范围越小越好
4.执行顺序：
静态代码块--》构造代码块--》构造方法【创建好对象】--》调用局部代码块所处的普通方法
5.为什么是这样的顺序呢？
因为静态代码块也是静态资源，静态资源随着类的加载而加载，优先于对象的创建
静态资源只加载一次，且一直存在，直到类的消失，它才会消失；而构造方法随着创建对象而触发，创建几次就触发几次。

练习：静态/构造/局部代码块之间的关系

package cn.tedu.block;
/**几种代码块的关系以及执行顺序*/
public class TestBlock {
    public static void main(String[] args) {
        //7.创建对象
        Phone p = new Phone();
        Phone p1 = new Phone();
        /**1.在创建对象（或者多个对象）之前会优先自动执行静态代码块，而且此静态代码块只执行一次，
         * 2.每次创建对象时，都会调用构造代码块与构造方法，构造代码块先执行
         * 3.当对象调用方法时，若方法里有局部代码块，局部代码块才会触发*/
        p.sleep();

    }
}
//1.Phone类
class Phone{
    //2.创建静态代码块
    /**静态代码块：
     * 位置：类里方法外
     * 触发时机：静态代码块也是静态资源，随着类的加载而加载，优先于对象加载，并且只加载一次的资源
     * 作用：用于专门完成一些需要第一时间就加载的资源*/
    static{
        System.out.println("我是静态代码块！！！");
    }

    //3.创建构造代码块
    /**构造代码块：
     * 位置：类里方法外
     * 触发时机：创建对象时触发，而且优先于构造方法执行
     * 作用：用于提取所有构造方法的共性内容*/
    {
        System.out.println("我是一个构造代码块~~");
    }

    //4创建构造方法
    /**构造方法：是与类同名且没有返回值类型的方法，用于创建对象，在创建对象时触发*/
     public Phone(){
         System.out.println("我是一只叫构造方法的狗狗");
     }
     //5.创建普通方法--功能
    public void sleep(){
        System.out.println("起来嗨！！");
        //6.创建局部代码块
        /**局部代码块：
         * 位置：普通方法里
         * 执行时机：调用本方法时触发
         * 作用：用来控制变量的作用范围，变量的作用范围越小越好*/
        {
            System.out.println("我是一枚局部代码块%%%");
        }
    }
}

3.final

final是一个关键字，表示最终
1）.被final修饰的类是最终类，不能被继承
2）.被final修饰的方法是方法的最终实现，不能被重写
3）.被final修饰的变量变成了一个常量，值不能被修改，常量在定义（声明）的时候就需要赋值，否则报错
4）.常量的定义形式：final 数据类型   常量名 = 值；

练习：final修饰的作用

package cn.tedu.oopfinal;
/**本类用于final的入门案例*/
public class TestFinal {
    public static void main(String[] args) {
        //6.创建Son类对象进行测试
        Son s = new Son();

        s.work();
        //s.work1();

       // s.name = "干饭人";//对父类的name重新赋值并查看
        System.out.println(s.name);
    }
}
//1.父类

/**1.Final表示最终，可以用来修饰类
 * 但是被final修饰的类无法被继承
 * 也就是没有子类，它自己就是最终类
 */
//7.1final class Father{//报错：Son不能继承被final修饰的Father类
class Father{
    //3.创建成员变量
    /**3.final可以用来修饰成员变量，被final修饰的变量值不可以被修改，变成了常量
     * 注意：常量在定义的时候就需要赋值，否则报错*/
    final String  name = "打工人";
    //String  name = "打工人";
    //4.创建普通方法
    //7.2final修饰方法
    //final public void work(){//报错：子类不可以重写父类中被final修饰的方法
    /**2.final可以用来修饰方法，被final修饰的方法是方法的最终实现，不能被重写*/
    public void work(){
        System.out.println("Father...打工人，打工魂~~");
    }

}
//2.子类并继承父类
class Son extends Father{
   public void work1(){//在新方法中调用父类方法
       super.work();
   }
    //5.创建子类重写父类的work方法
    public void work(){
        System.out.println("Son...现在打工人都用计算机打工！！！");
    }
}

4.面向对象之多态

面向对象的三大特征：封装private、继承extends、多态（继承+重写）

4.1多态：

指一类事物具有多种形式，比如：水果有苹果、橘子、香蕉等；动物有猫、狗、大象等

1.多态的前提继承+方法重写缺一不可

2.口诀1：父类引用  指向子类对象  如：Animal a = new Cat( );
   口诀2：编译(保存)看左边，运行(测试run)看右边   解释：方法的声明看父类，方法的实现看子类

练习：创建多态对象的过程

/**本类用于多态的入门案例*/
public class TestDemo {
    public static void main(String[] args) {
        //5.创建对象进行测试
        Animal a = new Animal();
        Cat c = new Cat();//格式：子类引用 = 子类对象
        Dog d = new Dog();
        a.eat();//小动物Animal吃啥都行~~
        c.eat();//小猫Cat爱吃小鱼干！！！
        // a.jump();//父类无法使用子类的特有功能
        c.jump();//小猫Cat跳的特别高@@@
        /**8.创建多态对象进行测试
         * 口诀1：父类引用  指向子类对象
         * 口诀2：编译(保存)看左边，运行(测试)看右边
         * 多态的两个前提：继承+重写缺一不可
         * 多态使用的是父类的声明，子类的具体实现*/
        Animal a2 = new Cat();
        a2.eat();//小猫Cat爱吃小鱼干！！！
        /**多态不可以调用子类特有的功能，只能调用重写的功能*/
        //a2.jump;//子类独有的功能，父类不能引用，引用的前提下是继承+重写
        Animal a3 = new Dog();
        a3.eat();//小动物Animal吃啥都行~~//因为Dog类没有重写，继承的是父类的方法
        /**多态的出现是为了统一调用标准，向父类看齐
         * 父类声明的功能才能用，子类特有的功能用不了
         * 如果想要子类的特有功能，就创建纯纯的子类对象*/
    }
}
//1.创建父类
class Animal{
    //4.创建父类普通方法
    public void eat(){
        System.out.println("小动物Animal吃啥都行~~");
    }


}
//2.子类小猫，继承父类Animal
class Cat extends Animal{
    //6.重写父类中的普通方法eat()
    @Override
    public void eat(){
        System.out.println("小猫Cat爱吃小鱼干！！！");
    }
    //7.定义子类猫中的特有方法jump()
    public void jump(){
        System.out.println("小猫Cat跳的特别高@@@");
    }

}
//3.子类狗，继承父类Animal
class Dog extends Animal{

}

4.2多态的使用

我们目前学习的多态对象都是把自己当做是一个父类类型，像花木兰替父从军一样，所以：
1）.多态对象不可以使用子类特有的功能
2）.多态对象使用的成员变量是父类的
3）.多态对象使用时，如果父子类中出现同名静态方法，使用的还是父类的
4）.多态对象在使用方法时，如果子类重写了，使用的是子类的方法体
TIPS:静态资源属于优先加载的类资源，静态方法不存在重写的现象

         谁的对象来调用，就使用对应父类或者子类的静态方法

         多态对象调用的静态方法是父类的，因为多态对象被看作是父类类型

         目前学习的多态只是多态的其中一种，可以叫做向上型类

练习：多态中成员变量、普通方法、和静态方法的使用

package cn.tedu.oop;
/*本类用于多态中元素的测试*/
public class TestDemo2 {
    public static void main(String[] args) {
        //8.创建子类对象进行测试
        Cat2 c =new Cat2();
        System.out.println(c.sum);//100
        c.eat();//子类对父类重写后的方法（功能）
        c.play();//子类对象调用自己特有的方法
        //9.创建多态对象进行测试
        /*口诀1：父类引用  指向子类对象
         * 口诀2：编译看左边，运行看右边*/
        Animal2 a =new Cat2();
        /*2.多态中，成员变量的使用都是父类的*/
        System.out.println(a.sum);//10
        /*3.多态中，方法的声明看的是父类的，实现使用的是子类的*/
        a.eat();//小猫爱吃吃小鱼干！！
        /*4.多态中如果父子类有同名的静态方法，使用的是父类的
        *因为多态对象被看作是父类类型*/
        a.play();//玩啥都行
    }
}
//1.父类
class Animal2{
    //3.成员变量-属性
    int sum = 10;
    //4.普通方法--行为功能
    public void eat(){
        System.out.println("吃啥都行~~~");
    }
    //10.创建父类中的静态方法
    public static void play(){
        System.out.println("玩啥都行");
    }
}
//2.子类Cat2
/*多态的前提是：继承+重写*/
class Cat2 extends Animal2{
    //5.成员变量--属性
    int sum = 100;
    //6.重写父类的普通方法eat()
    @Override/*@Overtide是一个注解，加在方法上，表示这是一个重写的方法*/
    public void eat(){
        System.out.println("小猫爱吃吃小鱼干！！");
    }
    //7.定义子类独有的方法
    //public  void play(){
    /*注意：静态资源属于类，不存在重写的现象
    *只是两个类中恰好有两个同名的静态方法而已*/
    public static void play(){
        System.out.println("小猫爱玩逗猫棒###");
    }


}

5.综合拓展

  设计汽车综合案例

package cn.tedu.design;
/*本类用于完成OOP汽车设计综合案例*/
public class DesignCar {
    public static void main(String[] args) {
        //8.创建程序的入口函数main（）方法
        //创建父类对象进行测试
        Car c = new Car();
        System.out.println(c.getColor());//null需要使用get（）/默认值
        c.start();//父类自己的功能
        c.stop();//父类自己的功能
        //c.fly();//父类不能使用子类特有的功能

        //9.创建一个宝马类对象
        BMW b =new BMW();
        System.out.println(b.color);//子类自己新定义的属性--五彩斑斓的黑
        b.start();//没有重写，使用的是父类的功能--我的车车启动了~~
        b.stop();//重写了，使用的是自己重写以后的功能--宝马当然要帅气的听的稳当些~~

        //10.创建一个保时捷类的对象
        BSJ b2=new BSJ();
        System.out.println(b2.getColor());//null
        System.out.println(b2.color);//黑不溜秋的白
        b2.start();//使用的是继承过来的父类中的功能
        b2.fly();//使用的是子类特有的功能
    }
}
//1.通过归纳总结，使用关键字class抽象封装形成一个“类”组件来描述一类事物
class Car{
    //2.属性--通过成员变量描述
    //2.1属性的封装--通过关键字private对属性封装
    private String brand;
    private String color;
    private double price;
    private double size;//尺寸


    //3.行为功能--通过普通方法描述
    public void start(){
        System.out.println("我的车车启动了~~");
    }
    public void stop(){
        System.out.println("我的车车熄火了！！！");
    }
    //2.2给被封装的属性通过公共的属性值设置和访问方式--setxxx和getxxx
    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public double getSize() {
        return size;
    }

    public void setSize(double size) {
        this.size = size;
    }
}

//4.创建一个宝马类并且继承汽车类--关键字extends
class BMW extends Car{
    String color = "五彩斑斓的黑";
    //6.子类对父类方法不满意时可以重写父类的方法
    //重写遵循两同两小一大原则，重写后，子类对象使用重写后的方法
    @Override
    public void stop(){
        System.out.println("宝马当然要帅气的听的稳当些~~");
    }
}
//5.创建一个保时捷类且继承汽车类--通过关键字extends建立继承关系
class BSJ extends Car{
    String color = "黑不溜秋的白";
    //7.新增子类特有功能
    public void fly(){
        System.out.println("保时捷的特有功能--飞行");
    }

}

心猿意码~~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值