Static，重写，静态代码块，final，多态

其他 2021-11-29 13:26:57 阅读次数: 0

static

可以修饰成员变量与成员方法
随着类的加载而加载，优先于对象加载
只加载一次，就会一直存在，不再开辟新空间, 直到类消失才一起消失
静态资源也叫做类资源,全局唯一,被全局所有对象共享
可以直接被类名调用
静态只能调用静态，非静态可以随意调用
static不能和this或者super共用，因为有static时可能还没有对象

静态区域内不允许使用this和super。

/**
 * 本类用于测试静态的调用关系
 * 总结：1.普通资源既可以调用普通资源，也可以调用静态资源
 * 2.静态资源只能调用静态资源
 *
 */
public class TestStatic2 {
    public static void main(String[] args) {

    }
}
class Teather{
    String name;//名字
    public  void teach(){
        /* 普通资源可以调用静态方法 */
        ready();
        System.out.println("授课ing...");
    }
    static int id; //工号
    public static void ready(){
        //静态资源能都否调用普通资源？不能
        System.out.println("备课ing...");
    }
    public static void eat(){
        /**
         * 静态资源能否调用静态资源？可以
         */
        System.out.println(id);   //静态方法调用静态属性
        ready();      //静态方法调用静态方法
    }
}

重写：

重写的原则：两同，两小，一大
     *两同：子类方法的方法名 与参数列表 和父类方法相同
     * 一大：子类方法的 方法修饰权限>=父类方法的
     * 量小：子类方法的返回值类型<=父类方法的返回值类型
     * 注意：这里所说的<=是指子类方法返回值是父类返回值类型的子类
     * 或者与父类的返回值保持一致，如果父类方法的返回值类型是void，子类保持一致即可

/**
 * 本类用与测试继承中方法的使用
 * 重写
 */
public class ExtendsDemo {
    public static void main(String[] args) {
       Father f=new Father();
       Son s=new Son();
       f.eat();
       s.eat();
       f.play();
       s.eat();

    }
}

class Father{
    public void eat(){
        System.out.println("爸爸爱吃肉~");
    }
    public void play(){
        System.out.println("爸爸爱放风筝~");
    }
}

class Son extends Father {
    /**
     * 重写的原则：两同，两小，一大
     *两同：子类方法的方法名 与参数列表 和父类方法相同
     * 一大：子类方法的 方法修饰权限>=父类方法的
     * 量小：子类方法的返回值类型<=父类方法的返回值类型
     * 注意：这里所说的<=是指子类方法返回值是父类返回值类型的子类
     * 或者与父类的返回值保持一致，如果父类方法的返回值类型是void，子类保持一致即可
     */
    @Override  //注解，用来加在方法上，表示这是一个重写的方法
    public void eat(){
        System.out.println("儿子爱吃蔬菜~");
    }
    @Override
    public void play(){
        System.out.println("儿子爱玩游戏~");
    }
}


爸爸爱吃肉~
儿子爱吃蔬菜~
爸爸爱放风筝~
儿子爱吃蔬菜~

静态代码块：

格式：

static{}

位置：类里方法外

执行时机：静态代码块也属于静态资源，随着类的加载而加载，优先于对象加载,并且静态资源只会加载一次。

作用：用于加载那些需要第一时间就加载，并且只加载一次的资源，常用来初始化

执行顺序：静态代码块，构造代码块，构造方法，普通方法 局部代码块


/**
 * 本类用于测试代码块
 * 静态代码块，构造代码块，构造方法，普通方法 局部代码块
 */
public class TestBlock {
    public static void main(String[] args) {
        new Apple();
        new Apple();
    }
}
class Apple{
    /**
     * 位置：类里方法外
     * 执行时机：静态代码块也属于静态资源，随着类的加载而加载，优先于对象加载,并且静态资源只会加载一次。
     * 作用：用于加载那些需要第一时间就加载，并且只加载一次的资源，常用来初始化
     */
    static{
        System.out.println("我是一个静态代码块");
    }
    {
        /**
         * 类里方法外
         * 创建对象时，并且优于构造方法执行
         * 用于提取所有构造的共性功能
         */
        System.out.println("我是代码块");
    }
    public  Apple(){
        System.out.println("我是一个无参构造");
    }
    public void clean(){
        System.out.println("我是一个普通方法");
        /**
         * 方法里
         * 每次调用局部代码块所处的方法时，才会执行
         * 用于控制变量的作用范围
         */
    }
}

我是一个静态代码块
我是代码块
我是一个无参构造
我是代码块
我是一个无参构造

final：

1.final可以用来修饰类，被fianl修饰的类是最终类，不可以被继承

2.可以把被final修饰的类看成树结构中的叶子节点

3.final可以用来修饰方法，被final修饰的方法是这个方法的最终实现，不可以被重写

4.被final修饰的是常量，常量的值不可以被修改

注意：不管是成员位置还是局部位置，常量定义的时候必须赋值

注意：常量的名称必须是全大写，单词与单词之间使用—分割

总结：

1.修饰类：

2.修饰方法：这个方法的最终实现，不可以被重写

3.修饰常量：值不可以被更改，并且常量定义时必须赋值

/**
 * 本类用于测试final关键字
 */
public class TestFinal {
    public static void main(String[] args) {
        new Son2().work();
    }
}

class Father2{
    public   void  work(){
        System.out.println("在工厂上班~");
    }
}
class Son2 extends Father2{
    /**
     * 被final修饰的是常量，常量的值不可以被修改
     * 注意：不管是成员位置还是局部位置，常量定义的时候必须赋值
     *  注意：常量的名称必须是全大写，单词与单词之间使用—分割
     */
    final  int A=100;
    public void  work(){
        int a=10;
        a=100;
        final  int B=100;
//        B=200; 报错：常量不可以被修改
        System.out.println("在互联网大厂上班~");
    }

}
在互联网大厂上班~

多态：

特点：

  • 多态的前提1：是继承
  • 多态的前提2：要有方法的重写
  • 父类引用指向子类对象,如：Animal a = new Cat();
  • 多态中，编译看左边，运行看右边
  • 解释：必须要在父类定义这个方法，才能通过编译，编译时，把多态对象看做是父类类型，必须要在子类重写这个方法，才能满足多态，实际是子类。
  • 多态的前提：继承+重写
  • 口诀：父类引用指向子类对象
  • 编译看左边，运行看右边
  • public class TestDemo {
    public static void main(String[] args) {
        Animal animal=new Animal();
        Cat cat=new Cat();
        Dog dog=new Dog();
        animal.eat();  //调用的是父类自己的功能
        cat.eat();  //调用的是自己重写的功能
        dog.eat();  //调用的是自己重写的功能
//      animal.jump(); 父类对象不可以使用子类特有的功能
        cat.jump();
        dog.run();
        /**
         * 创建多态对象
         * 父类引用指向子类对象
         * 解释：创建出来的子类对象的地址值，交给父类类型的引用类型变量来保存
         */
        Animal a2=new Cat(); //子类对象地址交给父类类型变量来保存
        Animal a3=new Dog();
        /**
         * 编译看左边，运行看右边
         */
        a3.eat();
    }
}
class Animal{
  public  void eat(){
      System.out.println("小动物Animal吃啥都行~");
    }
}
class Cat extends Animal{
  @Override
    public void eat(){
        System.out.println("小猫爱吃小鱼干~");
    }
    public void jump(){
        System.out.println("小猫cat跳的老高了~");
    }
}
class Dog extends Animal{
   @Override
    public void eat(){
        System.out.println("小狗爱吃肉骨头~");
    }
    public void run(){
        System.out.println("小狗dog跑的老快了~");
    }
}
小动物Animal吃啥都行~
小猫爱吃小鱼干~
小狗爱吃肉骨头~
小猫cat跳的老高了~
小狗dog跑的老快了~
小狗爱吃肉骨头~

    注意：多态中使用的成员变量是父类的。

  • package oop;
/**
 * 本类用于测试多态成员的使用情况
 */
public class TestDemo2 {
    public static void main(String[] args) {
        Dog2 dog2=new Dog2();
        System.out.println(dog2.sum); //20
        dog2.eat(); //小狗爱吃肉包子
        /**
         *口诀1：父类引用指向子类对象
         * 口诀2：编译看左边，运行看右边
         */
        Animal2 a=new Dog2();
        /**
         * 多态中使用的成员变量是父类的。
         */
        System.out.println(a.sum);   //父类的成员变量
         a.eat();    //小狗爱吃肉包子
        /**
         * 多态中调用的静态方法是父类的，因为多态对象把自己看作是父亲类型，直接使用父类中的静态资源
         */
        a.play(); //没有提示，玩啥都行
        Animal2.play();  

    }
}
 class Animal2{
    int sum=10;
    public  void  eat(){
        System.out.println("吃啥都行~");
    }
     /**
      * 定义父类的静态方法
      */
    public static void play(){
        System.out.println("玩啥都行~");
    }
 }
 class  Dog2 extends Animal2{
    int sum=20;
    public void eat(){
        System.out.println("小狗爱吃肉包子~");
    }

     /**
      * 静态方法不存在重写的功能
//      */
//     @Override  这不是重写的方法，只是恰巧在两个类中出现了一模一样的两个静态方法，
//     在哪个类里定义，就在哪个类的资源使用。
    public static  void play(){
        System.out.println("小狗喜欢玩皮球");
    }
 }

20
小狗爱吃肉包子~
10
小狗爱吃肉包子~
玩啥都行~
玩啥都行~

     多态综合案例：

    package oop;



public class DesignCar {
    public static void main(String[] args) {
       Car c=new Car();
       System.out.println(c.getColor());
       c.start();
       c.stop();
//      c.swim(); 父类对象不可以调用子类的特有功能
        BMW bmw=new BMW();
        System.out.println(bmw.color);
        System.out.println(bmw.getColor());
        bmw.start();
        bmw.stop();
        
      Car c2=new TSL();
        System.out.println(c2.getColor());
        c2.stop();
        c2.start();
        
        
    }
}
class Car{
   private String  brand;
    private String color;
    private int id;
    private double price;

    public void start(){
        System.out.println("我的小车车启动了~");
    }
    public void stop(){
        System.out.println("哎呀妈呀熄火了~");
    }

    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 int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }
}
class BMW extends Car{
    String color="五彩斑斓的黑";
    @Override
    public  void start(){
        System.out.println("都让开，我的车要起飞了~");
    }
}
class TSL extends Car{
    public void stop(){
        System.out.println("哎呀妈，怎么停不下来呢~");
    }
    public void swim(){
        System.out.println("没想到吧，我还是个潜水艇~");
    }
}


null
我的小车车启动了~
哎呀妈呀熄火了~
五彩斑斓的黑
null
都让开，我的车要起飞了~
哎呀妈呀熄火了~
null
哎呀妈，怎么停不下来呢~
我的小车车启动了~

猜你喜欢

转载自blog.csdn.net/weixin_43762083/article/details/120760928
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
循环神经网络（rnn）讲解
Tigao教程四：单独的关节运动
金蝶K3WISE15.0-注册套打教程
如何在Mac上配置Kubernetes
Android应用结束自身进程的方法
SpringMVC学习 十三 拦截器栈
中国驻洛杉矶总领馆举行新春招待会
HttpClient get post 发送
11 - three.js 笔记 - 绘制三维字体模型
Mysql递归获取某个父节点下面的所有子节点和子节点上的所有父节点
每日归档
更多
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022