zoukankan      html  css  js  c++  java
  • 2020/7/7 Java构造方法与关键字

    一、构造方法介绍

        在开发中经常需要在创建对象的同时明确对象的属性值。

        那什么是构造方法呢?从字面上理解即为构建创造时用的方法,即就是对象创建时要执行的方法。

        既然是对象创建时要执行的方法,那么只要在new对象时,知道其执行的构造方法是什么,就可以在执行这个方法的时候给对象进行属性赋值。

    //构造方法的格式:
    修饰符 构造方法名(参数列表)
    {
    }

        构造方法的体现:

          构造方法没有返回值类型。也不需要写返回值。因为它是为构建对象的,对象创建完,方法就执行结束。

          构造方法名称必须和类名保持一致。

          构造方法没有具体的返回值。

        

    //构造方法的代码体现:
    class Person {
        // Person的成员属性age和name
        private int age;
        private String name;
    
        // Person的构造方法,拥有参数列表
        Person(int a, String nm) {
            // 接受到创建对象时传递进来的值,将值赋给成员属性
            age = a;
            name = nm;
        }
    }

    二、构造方法的调用

        构造方法是专门用来创建对象的,也就是在new对象时要调用构造方法。

    class Person {
        // Person的成员属性age和name
        private int age;
        private String name;
    
        // Person的构造方法,拥有参数列表
        Person(int a, String nm) {
            // 接受到创建对象时传递进来的值,将值赋给成员属性
            age = a;
            name = nm;
        }
    
        public void speak() {
            System.out.println("name=" + name + ",age=" + age);
        }
    }
    
    class PersonDemo {
        public static void main(String[] args) {
            // 创建Person对象,并明确对象的年龄和姓名
            Person p2 = new Person(23, "张三");
            p2.speak();
        }
    }

    三、默认构造方法和细节

        在之前学习的过程中,描述事物时,并没有显示指定构造方法,当在编译Java文件时,编译器会自动给class文件中添加默认的构造方法。

        如果在描述类时,我们显示指定了构造方法,那么,当在编译Java源文件时,编译器就不会再给class文件中添加默认构造方法。

    class  Person {
        //如果没有显示指定构造方法,编译会在编译时自动添加默认的构造方法
        //public Person(){}  //空参数的默认构造方法
    }

        构造方法的细节:

          1、一个类中可以有多个构造方法,多个构造方法是以重载的形式存在的

          2、构造方法是可以被private修饰的,作用:其他程序无法创建该类的对象。

        

    class Person {
        private int age;
        private String name;
    
        // 私有无参数的构造方法,即外界不能通过new Person();语句创建本类对象
        private Person() {
        }
    
        // 多个构造方法是以重载的形式存在
        Person(int a) {
            age = a;
        }
    
        Person(String nm, int a) {
            name = nm;
            age = a;
        }
    }

    四、构造方法和一般方法的区别

        构造方法在对象创建时就执行了,而且只执行一次。

        一般方法是在对象创建后,需要使用时才被对象调用,并可以被多次调用。

        有了构造方法之后可以对对象的属性进行初始化,那么还需要对应的set和get方法吗?

        需要相应的set和get方法,因为对象在创建之后需要修改和访问相应的属性值时,在这时只能通过set或者get方法来操作。

    五、this关键字

        针对构造方法,无法通过构造方法名来相互调用。

        构造方法之间的调用,可以通过this关键字来完成。

        

    //构造方法调用格式:
    this(参数列表);
    
    构造方法的调用
    class Person {
        // Person的成员属性
        private int age;
        private String name;
    
        // 无参数的构造方法
        Person() {
        }
    
        // 给姓名初始化的构造方法
        Person(String nm) {
            name = nm;
        }
        // 给姓名和年龄初始化的构造方法
        Person(String nm, int a) {
            // 由于已经存在给姓名进行初始化的构造方法 name = nm;因此只需要调用即可
            // 调用其他构造方法,需要通过this关键字来调用
            this(nm);
            // 给年龄初始化
            age = a;
        }
    }

    六、super关键字

        1、子父类中构造方法的调用

            在创建子类对象时,父类的构造方法会先执行,因为子类中所有构造方法的第一行有默认的隐式super();语句。

            格式:

    调用本类中的构造方法
    this(实参列表);
    调用父类中的空参数构造方法
    super();
    调用父类中的有参数构造方法
        super(实参列表);

            子类中的构造方法为什么会有一句隐式的super()呢?

            原因:子类会继承父类中的内容,所以子类在初始化时,必须先到父类中去执行父类的初始化动作。这样,才可以使用父类中的内容。

            当父类中没有空参数构造方法时,子类的构造方法必须有显示的super语句,指定要访问的父类有参数构造方法。

        2、子类对象创建过程细节

            类中的构造方法默认第一行都有隐式的super()语句,在访问父类中的空参数构造方法。所以父类的构造方法既可以给自己的对象初始化,也可以给自己的子类对象初始化。

            如果默认的隐式super()语句在父类中没有对应的构造方法,那么必须在构造方法中通过this或者super的形式明确要调用的构造方法。

    七、final关键字

        有些类在描述完之后,不想被继承,或者有些类中的部分方法功能是固定的,不想让子类重写。可是当子类继承了这些特殊类之后,就可以对其中的方法进行重写

        要使用到一个关键字final,final的意思为最终,不可变。final是个修饰符,它可以用来修饰类,类的成员,以及局部变量。不能修饰构造方法。

        final的特点

        

    //final修饰类不可以被继承,但是可以继承其他类。
    class Yy {}
    final class Fu extends Yy{} //可以继承Yy类
    class Zi extends Fu{} //不能继承Fu类
    
    //final修饰的方法不可以被子类重写,但父类中没有被final修饰方法,子类重写后可以加final。
    class Fu {    
        // final修饰的方法,不可以被覆盖,但可以继承使用
        public final void method1(){}
        public void method2(){}
    }
    class Zi extends Fu {
        //重写method2方法
        public final void method2(){}
    }
    
    //final修饰的变量称为常量,这些变量只能赋值一次。而且终身不变。
    final int i = 20;
    i = 30; //赋值报错,final修饰的变量只能赋值一次
    
    //引用类型的变量值为对象地址值,地址值不能更改,但是地址内的对象属性值可以修改。
    final Person p = new Person();
    Person p2 = new Person();
    p = p2; //final修饰的变量p,所记录的地址值不能改变
    p.name = "小明";//可以更改p对象中name属性值
    //p不能为别的对象,而p对象中的name或age属性值可更改。
    
    //修饰成员变量,需要在创建对象前赋值,否则报错。(当没有显式赋值时,多个构造方法的均需要为其赋值。)
    class Demo {
        //直接赋值
        final int m = 100;
        
        //final修饰的成员变量,需要在创建对象前赋值,否则报错。
        final int n; 
        public Demo(){
            //可以在创建对象时所调用的构造方法中,为变量n赋值
            n = 2016;
        }
    
    }

    八、static关键字

        static它是静态修饰符,一般用来修饰类中的成员。

        1、static的特点:

            被static修饰的成员变量属于类,不属于这个类的某个对象。

            也就是说,多个对象在访问或修改static修饰的成员变量时,其中一个对象将static成员变量值进行了修改,

            其他对象中的static成员变量值跟着改变,即多个对象共享同一个static成员变量)

        2、static修饰的成员可以并且建议通过类名直接访问。

            访问静态成员的格式:

              类名.静态成员变量名

              类名.静态成员方法名(参数)

              对象名.静态成员变量名      ------不建议使用该方式,会出现警告

              对象名.静态成员方法名(参数) ------不建议使用该方式,会出现警告

        3、static注意事项

            静态内容是优先于对象存在,只能访问静态,不能使用this/super。静态修饰的内容存于静态区。

            同一个类中,静态成员只能访问静态成员

            main方法为静态方法仅仅为程序执行入口,它不属于任何一个对象,可以定义在任意类中。

            多态调用方法中,编译看=左边,父类有,编译成功,父类没有,编译失败

            运行,静态方法,运行父类中的静态方法,

            运行,非静态方法,运行子类的重写方法

            成员变量,编译运行全是父类

     

  • 相关阅读:
    【算法学习笔记】76.DFS 回溯检测 SJTU OJ 1229 mine
    【算法学习笔记】75. 动态规划 棋盘型 期望计算 1390 畅畅的牙签盒(改)
    【算法学习笔记】74. 枚举 状态压缩 填充方案 SJTU OJ 1391 畅畅的牙签袋(改)
    【算法学习笔记】73.数学规律题 SJTU OJ 1058 小M的机器人
    【算法学习笔记】72.LCS 最大公公子序列 动态规划 SJTU OJ 1065 小M的生物实验1
    【算法学习笔记】71.动态规划 双重条件 SJTU OJ 1124 我把助教团的平均智商拉低了
    【算法学习笔记】70.回文序列 动态规划 SJTU OJ 1066 小M家的牛们
    【算法学习笔记】69. 枚举法 字典序处理 SJTU OJ 1047 The Clocks
    【算法学习笔记】68.枚举 SJTU OJ 1272 写数游戏
    【算法学习笔记】67.状态压缩 DP SJTU OJ 1383 畅畅的牙签袋
  • 原文地址:https://www.cnblogs.com/luzhijin/p/13262509.html
Copyright © 2011-2022 走看看