栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

static和继承

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

static和继承

static

  1. static特点
    问题:
  2. static关键字的运用有什么好处?
  3. static可以修饰哪些代码部分?
  4. 被static修饰的内容,推荐如何调用?
    概述:static关键字是静态的意思,是Java中的一个修饰符,可以修饰成员方法、成员变量
    修饰的成员变量叫静态变量
    修饰的成员方法叫静态方法
    static修饰的特点:
    被该类所有的对象所共享
    随着类的加载而加载,优先于对象存在
    可以通过类名调用,也可以通过对象名调用。推荐使用类名调用

    public class Student {
    static String name;
    int age;
    static String school;
    …
    }
    public class Test01 {
    public static void main(String[] args) {
    //2.被static修饰的成员,多了一种调用方式,可以通过 “类名.静态成员” 进行调用
    Student.school=“厦门大学”;
    System.out.println(Student.school);
    School.study();

       //1.被static修饰的成员变量会被所有对象共享
       Student stu1 = new Student("张三", 19, "清华大学");
       stu1.show();
       Student stu2 = new Student("李四", 20, "北京大学");
       stu2.show();
       //再用张三调用show方法
       stu1.show();//效果是学校改变了,但是张三并没有修改学校信息
       //只有李四有修改学校信息,证明了被static修饰的成员变量会被所有对象共享
    

    }
    }
    2. 注意事项
    问题:
    1.为什么在main方法中不能直接调用本类的其他非静态方法?
    2.静态方法中,能否使用this关键字?
    注意事项:
    静态方法中,只能访问静态的成员变量和成员方法
    在非静态方法中,可以使用静态成员,也可以使用非静态成员
    静态方法中,没有this关键字
    3. 代码块
    问题:
    1.什么是代码块?
    3.每种代码块,它的作用是什么?
    概述:在Java中,使用 { } 括起来的代码被称为代码块
    代码块分类:
    局部代码块
    位置: 方法中定义
    作用: 限定变量的生命周期,及早释放,提高内存利用率
    构造代码块
    位置: 类中方法外定义
    特点: 每次构造方法执行的时,都会执行该代码块中的代码,并且在构造方法执行前执行
    作用: 将多个构造方法中相同的代码,抽取到构造代码块中,提高代码的复用性
    静态代码块
    位置: 类中方法外定义
    特点: 需要通过static关键字修饰,随着类的加载而加载,并且只执行一次
    作用: 在类加载的时候做一些数据初始化的操作
    代码案例:

    class Student {
    {
    System.out.println(“好好学习”);
    }
    public Student(){
    System.out.println(“空参数构造方法”);
    }
    public Student(int a){
    System.out.println(“带参数构造方法…”);
    }
    }
    ​
    public class TestStudent {

    public static void main(String[] args) {
    Student stu1 = new Student();
    Student stu2 = new Student(10);
    }
    }
    ​

    class Person {
    static {
    System.out.println(“我是静态代码块, 我执行了”);
    }
    ​
    public Person(){
    System.out.println(“我是Person类的空参数构造方法”);
    }
    ​
    public Person(int a){
    System.out.println(“我是Person类的带…参数构造方法”);
    }
    }
    public class TestPerson {
    public static void main(String[] args) {
    Person p1 = new Person();
    Person p2 = new Person(10);
    }
    }

    1. 单例设计模式
      设计模式
      在软件开发中经常会遇到一些问题,这些问题如何解决,前人总结了一些好的方法,这些方法就称之为设计模式
      用设计模式去解决这些问题,可以使代码的安全性、重用性、扩展性更强
      单例模式
      在开发中我们经常会遇到这么一个问题:在设计类时,要保证这个类的实例对象只能有一个
      单例模式就是可以让类只能由一个对象的写代码方式
      使用场景
      任务管理器对象我们只需要一个就可以解决问题了,这样可以节省内存空间

    单例模式种类
    饿汉单例模式
    定义对象属性时就创建对象
    懒汉单例模式
    定义对象属性时不创建对象,而是在调用获取对象的方法时才去创建对象
    设计步骤
    将类的构造器私有,避免外界利用构造器随意创建该类对象
    在类中定义一个属性,属性类型就是该类自己
    定义一个方法,用于返回该类唯一的对象
    如果是饿汉式,在定义属性的时候,就创建对象给属性初始化
    如果是懒汉式,在定义属性的时候不创建对象,把创建对象操作放到获取该类唯一对象的方法中
    继承

    1. 继承入门
      问题:
    2. 学习继承有什么作用,在什么时候可以使用?
    3. 如何使用继承,优化我们的黑马信息管理系统?
      概述:让类与类之间产生关系(子父类关系),子类则可以使用父类中非私有的成员
      继承的格式:
      格式:public class 子类名 extends 父类名{ }
      范例:public class Zi extends Fu{ }
      Fu:是父类,也被称为基类、超类
      Zi:是子类,也被称为派生类
      课堂案例:

      ​
      1. 继承的好处和弊端
        问题:
        1.继承是如何提高代码的可维护性?
        2.什么是代码的耦合性?
        3.什么时候可以使用继承优化代码?
        继承好处
        提高了代码的复用性
        提高了代码的维护性
        让类与类之间产生了关系,是多态的前提
        继承弊端
        增强了代码的耦合性:代码与代码之间存在关联都可以将其称之为"耦合"
        继承是侵入性的
        降低了代码的灵活性:继承关系,导致子类必须拥有父类非私有属性和方法,让子类自由的世界中多了写约束
        继承的使用场景
        需要考虑类与类之间是否存在is…a的关系,不能盲目使用继承
        is…a的关系:谁是谁的一种,例如:
        老师和学生是人的一种,那人就是父类,学生和老师就是子类
        猫和狗的关系:猫和狗都是动物的一种,那动物就是父类,猫和狗就是子类

      2. Java中继承的特点
        问题:
        1.java中使用多层继承的好处是什么?
        2.为什么java不支持多继承?
        特点:Java中类只支持单继承,不支持多继承,但支持多层继承
        支持单继承,不支持多继承:一个类只能继承一个父类,不同同时继承多个类
        错误范例1: class 儿子 extends 亲爹,干爹{ }
        错误范例2: class 儿子 extends 亲爹 extends 干爹{ }
        Java中类支持多层继承:父类继承爷爷类,再让儿子类继承父类。这样儿子类就可以使用父类和爷爷类的共有内容了
        不支持多继承的原因:如果可以多继承,两个父类有完全相同的方法,子类究竟使用谁的呢?
        //练习场景:假设儿子类既想拥有父亲的驾驶能力,也想拥有爷爷的喝酒天赋,就可以使用多层继承
        //1.有爷爷类
        public class 爷爷{
        public void drink(){
        System.out.println(“日饮三斤”);
        }
        }
        //2.让父亲类继承爷爷类
        public class 父亲 extends 爷爷{
        //父亲拥有自己的驾驶方法
        public void driver(){
        System.out.println(“秋名山车神,漂移过弯”);
        }
        }
        //3.让儿子继承父亲类
        public class 儿子 extends 父亲{
        //用一个方法,可以同时调用父亲和爷爷的方法
        public void extendsMethod(){
        drink();
        driver();
        }
        }

      3. 继承中变量的访问特点
        问题:

      4. 在子类方法中,访问一个子类和父类中同名的成员变量,默认访问谁的?

      5. 在子类方法中访问变量,访问查找的顺序是怎样的?

      6. 如果要指定访问父类的成员变量,可以如何处理?
        在子类方法中访问一个变量,采用的是就近原则。
        子类局部范围找。在方法栈内存当中搜搜
        子类成员范围找。方法栈中找不到,因为对象调用方法的联系,索引到该对象存在的堆内存空间
        父类成员范围找。说明子类对象堆内存空间,持有了父类对象的堆内存空间地址
        如果都没有就报错(不考虑父亲的父亲…)
        注意事项:
        如果子父类,出现了重名的成员变量,通过就近原则,会优先使用子类的
        如果一定要使用父类的,可以通过super关键字,进行区分
        代码练习:

        ​
        public class Fu {
        private String name = “张三”;
        private int age = 35;
        String car = “兰博基尼”;
        ​
        public void drive() {
        System.out.println(name + “驾驶着” + car + “在环线上驰骋”);
        }
        …
        }
        public class Zi extends Fu {
        private String name = “张三丰”;
        private int age = 18;
        String car = “五菱宏光”;
        public void drive() {
        System.out.println(name + “驾驶着” + car + “在环线上驰骋”);
        //通过super关键字,访问父类的成员变量
        System.out.println(name + “驾驶着” + super.car + “在环线上驰骋”);
        }
        …
        }
        ​
        //测试类代码:
        Fu fu = new Fu();
        Zi zi = new Zi();
        fu.drive();
        zi.drive();
        //1.儿子的内容并没有设置成功,因为父类的属性私有了,继承过来的set方法实际上是给父类对象赋值
        //2.让自己也拥有setget方法
        //3.如果父类和子类有同样的私有成员,子类必须重写自己的setget方法
        // 如果想要让Zi类对象调用drive方法,打印的内容是驾驶父类对象的车,应如何处理
        //4.如果手动创建父类和子类对象,要想让子类对象使用到父类对象的属性值,先给定
        模拟场景:酷狗音乐的皮肤切换
        默认皮肤(子类):

        父类皮肤(父类):

        有时候要用子类默认的属性,有时候要用父类的属性,怎么办?
        5. this和super访问成员的格式
        问题:
        1.super和this分别代表什么?
        2.super访问父类成员方法的格式是怎样的?
        3.能否通过"super.父类名()"的形式访问父类空参构造方法?
        super关键字的用法和this关键字的用法相似:
        this:代表本类对象的引用
        super:代表父类存储空间的标识(可以理解为父类对象引用)


        public void toggle() {
        //1.给flag做求反操作,每调用一次toggle方法,flag就取相反的值
        flag = !flag;
        //2.这个现象就和灯盘开关是一样的
        //3.要根据flag的值去切换主题
        //默认是false,切换之后变成true
        if (flag) {
        //变成ture要能显示咖啡色,咖啡色是父类的属性
        //所以使用super.父类的风格,把咖啡色拿到,给本类的face赋值
        //因为show方法打印的是face,如果给style赋值,打印的是face,就没有变化
        face = super.style;
        } else {
        //如果flag是false,显示默认主题,拿到当前类的属性,利用this
        //当前类属性值蓝色,给face赋值,利用show方法打印蓝色
        face = this.style;
        }
        show();
        }
        }
        ​
        6. 继承中成员方法的访问特点
        PC端微信聊天功能列表:表情、文件、截图、聊天记录、直播、语音聊天

        PC端企业微信聊天功能:表情、文件、截图、聊天记录、直播、图片、微文档、发起收款、会议、应用等等

        如果是微信是父类,企业微信是子类,为了提高代码的复用性,相同功能可以直接使用父类的;
        这就涉及到继承中,子类对象访问父类成员方法的情况;
        而且两个微信中,企业微信和微信的表情库不一样,那么就存在子类和父类有同名方法的情况,这种时候我们该如何处理呢?
        问题:

        1. 如果子类和父类有同名的方法,在子类中访问该方法,访问的是谁的?
        2. 通过子类对象访问成员方法,查找的顺序是怎样的?
          通过子类对象访问一个方法
          子类成员范围找
          父类成员范围找
          如果都没有就报错(不考虑父亲的父亲…)

        public class Fu {
        public void show() {
        System.out.println(“父类的show方法”);
        }
        }
        ​
        public class Zi extends Fu {
        public void show() {
        System.out.println(“子类的show方法”);
        //访问父类show方法
        super.show();
        }
        }
        ​
        public class Test01 {
        public static void main(String[] args) {
        //创建子类对象
        Zi zi = new Zi();
        zi.show();
        }
        }

        ​
        7. 方法重写概述和应用场景
        有时候,儿子的某些能力会比老子更强
        比如,老王和他老婆

        王思聪和他的老婆们

        既然儿子的功能更优秀,那么如何在代码上体现青出于蓝而胜于蓝呢?
        问题:
        1.什么时候是方法重写,代码格式有什么特点?
        2.方法重写的作用是什么,在什么时候能用到?
        方法重写概述
        子类出现了和父类中一模一样的方法声明(方法名,参数列表,返回值类型)
        方法重写的应用场景
        当子类需要父类的功能,而功能主体子类有自己特有内容,可以重写父类中的方法,这样,即沿袭了父类的功能,又定义了子类特有的内容
        代码案例

        class OldToiletSeat{
        public void function() {
        System.out.println(“防止沾到尿,保护屁屁的卫生”);
        }
        }
        ​
        class NewToiletSeat extends OldToiletSeat{
        public void function() {
        super.function();
        System.out.println(“保温,让你的冬天不再寒冷”);
        System.out.println(“水洗,让你的菊花不再疼痛,舒爽一整年”);
        }
        }
        ​
        public class Test01 {
        public static void main(String[] args) {
        OldToiletSeat oldToiletSeat = new OldToiletSeat();
        oldToiletSeat.function();
        System.out.println(“====================”);
        NewToiletSeat newToiletSeat = new NewToiletSeat();
        newToiletSeat.function();
        }
        }

        1. 方法重写的注意事项
          问题:

        2. 父类中哪些方法是无法被子类重写的?

        3. 子类重写父类的方法时,对于方法的访问权限有什么要求?
          父类中私有方法不能被重写
          父类静态方法,子类必须通过静态方法进行重写,父类非静态方法,子类也必须通过非静态方法进行重写
          静态方法不能被重写,如果子类也有相同的方法,并不是重写的父类的方法。可以理解为,子类将父类中同名的方法隐藏了起来,并非是方法重写!
          子类重写父类方法时,访问权限必须大于等于父类(public > 默认 > 私有)
          Override注解:
          用来检测当前的方法,是否是重写的方法,起到【校验】的作用
          //案例
          public class Fu {
          private void show() {
          System.out.println(“Fu中show()方法被调用”);
          }
          ​
          void method() {
          System.out.println(“Fu中method()方法被调用”);
          }
          }
          ​
          public class Zi extends Fu {
          ​

          @Override
          private void show() {
          System.out.println(“Zi中show()方法被调用”);
          }


          ​

          1. 继承中构造方法的访问特点

          请问,在1954年以前,有没有王思聪这个富二代?
          问题:

          1. 创建子类对象时,是否会先初始化父类对象?
          2. 调用子类的有参构造方法时,会调用父类的什么构造方法?
          3. 如果一个类没有指明继承关系,那么它就没有父类吗?
            子类中所有的构造方法默认都会访问父类中无参的构造方法
            原因:
            子类在初始化的时候,有可能会使用到父类的数据,如果父类没有完成初始化,子类将无法使用父类的数据。所以,子类初始化之前,一定要先完成父类数据的初始化。
            怎样完成初始化:
            构造方法的第一条语句默认都是:super()
            注意:
            如果我们编写的类,没有手动指定父类,系统也会自动继承Object(Java继承体系中的最顶层父类)
            如果父类只有有参的构造方法,在子类定义构造方法中,要实现空参构造的话,要先执行父类的有参构造,及super(*)的格式。
            /
          • 案例:分别创建一个父类Person和一个子类Student
          • 1.分别添加父类、子类的空参、有参构造
          • 2.分别在父类、子类的空参、有参构造中添加可以识别的打印语句
          • 3.在测试类中创建子类对象,查看父类、子类的构造方法调用情况
            */
            ​
          1. 构造方法的访问特点:父类没有空参构造方法
            问题:
            1.如果父类没有空参构造方法,只有带参构造方法,会出现什么现象?
            2.如何解决父类没有空参构造方法的问题?
            3.能不能在构造方法中同时调用this()和super()?
            解决方案:
            子类通过super,手动调用父类的带参构造方法
            子类通过this去调用本类的其他构造方法,本类其他构造方法再通过super去手动调用父类的带参的构造方法(不推荐)
            注意事项:
            this(…)和super(…) 必须放在构造方法的第一行有效语句,并且二者不能共存
            如果this和super共存,就意味着子类对象有两个爹,这是不允许的。
            //案例演示:
            ​
            class Fu{
            private String name;
            ​
            public Fu(String name) {
            this.name = name;
            }
            }
            ​
            public class Zi extends Fu{
            private int age;
            private String sex;
            public Zi(int age) {
            //1.使用super手动调用父类的有参构造
            super(“老王”);//得到一个父类对象
            // this(“人妖”)
            this.age = age;
            }
            public Zi(String sex) {

            //super();//得到一个父类对象
            this(23);
            this.sex = sex;
            }
            }
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/979146.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号