2022-08-31  阅读(1)
原文作者:唯一浩哥 原文地址:https://www.jianshu.com/u/c52a29db48b6

一、this关键字

this代表当前对象,它有以下几种用途:

  1. 本类中在非静态方法中条用非静态变量和方法,就可以使用【this.变量名】和【this.方法名(参数列表)】的方式调用,实际情况是,this关键字通常会被省略。
  2. 就在上面这种情况下,有一个特殊情况,那就是在方法中定义了一个与类成员变量同名的局部变量,这是在方法内部调用类的成员变量就必须使用this关键字来点用。
  3. 在构造方法中使用:在存在构造方法重构(overlode)的类中,使用【this(参数列表)】的方式调用本类中的其他构造方法,且必须放置于构造方法的第一句。

二、super关键字

super代表父类对象,它与this不同,用途如下:

  1. 子类重写父类方法之后,再次调用父类的该方法,必须使用【super.方法名(参数列表)】调用。
  2. 子类的构造方法中默认存在父类的无参构造方法,也可以显式声明其他的构造方法,声明必须使用【super(列表参数)】。
  3. 在构造方法中,super与this关键字不能同时出现,且均位于构造方法首行。

三、类的封装

为了保护类内部内容的安全,不被客户程序任意调用,将这些内容修饰为private,这些内容将只会对本类可见,包括子类在内的任何异类均无访问权限,为了实现对这些数据的访问修改,添加了setName(参数列表)和getName()公共方法来被外部类调用。这样避免了数据的无端访问,保护了数据的安全,即封装。

四、类的继承

  1. 一个类可以继承另一个类,这样前者就拥有后者内部的所有内容,但是父类中的被private修饰的内容子类是无法访问的,这时在子类中使用父类中的内容相当于使用本类中的内容。
  2. 被final修饰的类无法被继承。
  3. 一个类只能继承一个类,即单继承,继承使用extends关键字。
  4. 构造方法不能被继承
  5. 父类中的静态变量在子类中访问时,可以you父类点用,子类点用,直接使用三种方式,他们的作用一样。
  6. 子类的构造方法必须包含父类的构造方法,即在创建子类的对象实例时,会优先调用父类的构造方法来创建父类的实例对象,再调用子类的构造方法创建子类的实例对象。
  7. 子类汇总的构造方法默认调用父类的无参构造方法(隐式调用),亦可人为显式指定某个父类构造方法:使用【super(参数列表)】调用
  8. 类的继承通常会使用到重写操作(override),在保证父类某个方法的返回值、名称、参数列表不变的情况下优化更改方法体,重写后的方法不能使用比父类中被重写方法的更严格的权限修饰。
  9. 父类中的某个方法被子类重写之后,想要调用父类中的原方法,需要借助【super.方法名(参数列表)】调用。
  10. 在子类创建对象时,会在内存中加载子类字节码文件,加载时发现其继承自父类,那么会转向加载父类的字节码文件,在父类的字节码文件加载完成后,再返回来继续加载子类的字节码文件,加载完成后才会开始执行创建对象操作,创建子类对象时,调用子类构造方法必然会先调用父类的构造方法创建父类的对象,之后才会创建子类对象。

下面是实验代码:自行查看

            public class Test {
        
                //声明父类的成员变量
                private String name;
                protected static int age;//此处设置为protected,目的是为了试验主类静态变量的调用方式的区别
                private String sex;
        
                //声明父类的成员方法
                public String getName() {
                    return name;
                }
                public void setName(String name) {
                    this.name = name;//此处使用this用于区分类的成员变量与该方法的局部变量
                }
                public int getAge() {
                    return age;
                }
                public void setAge(int age) {
                    this.age = age;
                }
                public String getSex() {
                    return sex;
                }
                public void setSex(String sex) {
                    this.sex = sex;
                }
        
                //父类的outPut()方法
                public void outPut(){
                    System.out.println("我叫"+name+",今年"+age+"了,我是"+sex+"孩!");
                }
        
                //父类的构造方法(无返回值)
                //无参构造方法
                public Test(){
                    System.out.println("父类无参构造方法");
                }
                //带参数的构造方法
                public Test(int i){
                    this();
                    System.out.println("先调用无参构造方法,在执行这句创建父类对象");
                }
            }

下面是子类:

            public class SubTest extends Test{
        
                //子类的自有变量
                private String tel;
        
                //子类自有方法
                public String getTel() {
                    return tel;
                }
                public void setTel(String tel) {
                    this.tel = tel;
                }
        
                //重写父类outPut()方法
                public void outPut(){
                    System.out.println("我叫"+getName()+",今年"+getAge()+"了,我是"+getSex()+"孩,我的电话是"+getTel());
                }
        
                //子类的构造方法
                //子类的无参构造方法
                public SubTest(){
                    this(2);//此处不会直接调用父类的构造方法
                    System.out.println("先调用本类中的有参数构造方法,在执行此句");
                }
                //子类的有参数构造方法
                public SubTest(int j){
                    super(3);
                    System.out.println("会先调用父类的有参数构造方法创建父类对象,之后执行此句");
                }
                //主方法
                public static void main(String[] args) {
        
                    //这三种调用方式效果一样
                    System.out.println("这是测试父类的静态变量的调用方式的区别:无区别,效果一致");
                    Test.age=1;
                    SubTest.age=2;
                    age=3;
                    //输出上边的结果
                    System.out.println(Test.age+" "+SubTest.age+" "+age);//此处输出结果为333
                    System.out.println("****************************");
                    //在静态方法中调用非静态成员需要创建实例对象,由于要使用到父类与子类所有的变量与方法,所以创建子类的实例对象即可。
                    System.out.println("下面测试子类中创建对象实例的过程");
                    SubTest  test = new SubTest();
                    System.out.println("****************************");
                    System.out.println("下面测试队封装性父类进行赋值");
                    test.setName("张三");//赋值
                    test.setAge(20);//赋值
                    test.setSex("男");//赋值
                    test.setTel("12345678910");//赋值
                    test.outPut();//输出结果为:我叫张三,今年20了,我是男孩,我的电话是12345678910
                }
            }

下方为输出结果:

        
            这是测试父类的静态变量的调用方式的区别:无区别,效果一致
            3 3 3
            ****************************
            下面测试子类中创建对象实例的过程
            父类无参构造方法
            先调用无参构造方法,在执行这句创建父类对象
            会先调用父类的有参数构造方法创建父类对象,之后执行此句
            先调用本类中的有参数构造方法,在执行此句
            ****************************
            下面测试队封装性父类进行赋值
            我叫张三,今年20了,我是男孩,我的电话是12345678910

来源:https://www.jianshu.com/u/c52a29db48b6


Java 面试宝典是大明哥全力打造的 Java 精品面试题,它是一份靠谱、强大、详细、经典的 Java 后端面试宝典。它不仅仅只是一道道面试题,而是一套完整的 Java 知识体系,一套你 Java 知识点的扫盲贴。

它的内容包括:

  • 大厂真题:Java 面试宝典里面的题目都是最近几年的高频的大厂面试真题。
  • 原创内容:Java 面试宝典内容全部都是大明哥原创,内容全面且通俗易懂,回答部分可以直接作为面试回答内容。
  • 持续更新:一次购买,永久有效。大明哥会持续更新 3+ 年,累计更新 1000+,宝典会不断迭代更新,保证最新、最全面。
  • 覆盖全面:本宝典累计更新 1000+,从 Java 入门到 Java 架构的高频面试题,实现 360° 全覆盖。
  • 不止面试:内容包含面试题解析、内容详解、知识扩展,它不仅仅只是一份面试题,更是一套完整的 Java 知识体系。
  • 宝典详情:https://www.yuque.com/chenssy/sike-java/xvlo920axlp7sf4k
  • 宝典总览:https://www.yuque.com/chenssy/sike-java/yogsehzntzgp4ly1
  • 宝典进展:https://www.yuque.com/chenssy/sike-java/en9ned7loo47z5aw

目前 Java 面试宝典累计更新 400+ 道,总字数 42w+。大明哥还在持续更新中,下图是大明哥在 2024-12 月份的更新情况:

想了解详情的小伙伴,扫描下面二维码加大明哥微信【daming091】咨询

同时,大明哥也整理一套目前市面最常见的热点面试题。微信搜[大明哥聊 Java]或扫描下方二维码关注大明哥的原创公众号[大明哥聊 Java] ,回复【面试题】 即可免费领取。

阅读全文