精华内容
下载资源
问答
  • 2021-11-06 17:02:26

    一、什么是构造函数

    Java构造函数,也叫构造方法,是JAVA中一种特殊的函数。与函数名相同,无返回值。

    作用:
    一般用来初始化成员属性和成员方法的,即new对象产生后,就调用了对象的属性和方法。

    构造函数和一般函数的对比:
            (1)构造函数是对象一建立就运行,给对象初始化,就包括属性,执行方法中的语句,而一般函数是对象调用才执行,用 ".方法名" 的方式,给对象添加功能。

             (2)一个对象建立,构造函数只运行一次,而一般函数可以被该对象调用多次。

    构造函数的特点:

            (1)函数名与类名相同

            (2)不用定义返回值类型。

            (3)不可以写return语句。

            注:一般函数不能调用构造函数,只有构造函数才能调用构造函数。

    二、构造函数的重载

    Java中构造函数的重载指多个函数可以使用同一个函数名,只要它们参数列表不同,将意义相近的函数,命名为相同的名称。

    重载总结:
            ⑴函数重载是指多个函数使用同一个名称;

            ⑵重载的条件是参数的数量和类型不同;

            ⑶重载作用:降低调用的难度,用一个函数实现多种功能;

            ⑷当调用重载的函数时,计算机层根据实参自己匹配。

    三:static方法

          (1)static方法
            static方法就是没有this的方法。在static方法内部不能调用非静态方法,反过来是可以的。而且可以在没有创建任何对象的前提下,仅仅通过类本身来调用static方法。这实际上正是static方法的主要用途。

            正如上面所讲static方法一般称作静态方法,由于静态方法不依赖于任何对象就可以进行访问,因此对于静态方法来说,是没有this的,因为它不依附于任何对象,既然都没有对象,就谈不上this了。并且由于这个特性,在静态方法中不能访问类的非静态成员变量和非静态成员方法,因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。但是要注意的是,虽然在静态方法中不能访问非静态成员方法和非静态成员变量,但是在非静态成员方法中是可以访问静态成员方法/变量的。

            (2)static变量
            static变量也称作静态变量,静态变量和非静态变量的区别是:静态变量被所有的对象所共享,在内存中只有一个副本,它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的,在创建对象的时候被初始化,存在多个副本,各个对象拥有的副本互不影响。
            static成员变量的初始化顺序按照定义的顺序进行初始化

            (3)static代码块
            static关键字还有一个比较关键的作用就是用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方,类中可以有多个static块。在类初次被加载的时候,会按照static块的顺序来执行每个static块,并且只会执行一次。  为什么说static块可以用来优化程序性能,是因为它的特性:只会在类加载的时候执行一次。

    四、final关键词

     注意:(final的作用随着所修饰的类型而不同)

    (1)final修饰类中的属性或者变量
            无论属性是基本类型还是引用类型,final所起的作用都是变量里面存放的“值”不能变,这个值,对于基本类型来说,变量里面放的就是实实在在的值,而引用类型变量里面放的是个地址,所以用final修饰引用类型变量指的是它里面的地址不能变,并不是说这个地址所指向的对象或数组的内容不可以变,这个一定要注意。

             final修饰属性,声明变量时可以不赋值,而且一旦赋值就不能被修改了。对final属性可以在三个地方赋值:声明时、初始化块中、构造方法中。总之一定要赋值。      

    (2)final修饰类中的方法
             作用:可以被继承,但继承后不能被重写。

     (3)final修饰类
             作用:类不可以被继承。

    五、封装

    (1)封装的好处:
            可以让程序内部结构更安全;可以把重复的代码封装,之后再需要的地方进行调用,在一定程度上解决了代码的重复

    (2)封装的属性要提供setter和getter方法
    (3)setter 和getter方法的书写规则:
            setter 方法: set+首写字母大写的属性名, 没有返回值(void),有参数。

            getter 方法: get+首写字母大写的属性名,有返回值,没有参数。
     

    更多相关内容
  • 什么是java构造函数

    2021-03-06 00:12:38
    构造函数是面向对象中的一员,构造函数可以叫做构造器,它的函数名与类名相同,不用定义返回值类型,也没有具体的返回值。构造函数是在构建创造时对象时调用函数,作用是可以给对象进行初始化,创建对象都必须要通过...

    2750f290c6b2b001b369974075ef8df5.png

    构造函数是面向对象中的一员,构造函数可以叫做构造器,它的函数名与类名相同,不用定义返回值类型,也没有具体的返回值。构造函数是在构建创造时对象时调用函数,作用是可以给对象进行初始化,创建对象都必须要通过构造函数初始化。一个类中如果没有定义过构造函数,那么该类会有一个默认的空参数构造函数。如果在类中定义了指定的构造函数,那么该类中的默认构造函数就没有了。

    我们人出生的时候,有些人一出生之后再起名字的,但是有些人一旦出生就已经起好名字的。那么我们在java里面怎么在对象一旦创建就赋值呢?

    7bf03fffbfebe357fe704f812872e68c.png

    da44963ea6b7223c4f9a87167524cca2.png

    1.构造方法的作用:

    构造方法作用:对对象进行初始化。

    如图:

    2e2a5dd7de7d60444b6c972116a84968.png

    2.构造函数与普通函数的区别:

    (1)一般函数是用于定义对象应该具备的功能。而构造函数定义的是,对象在调用功能之前,在建立时,应该具备的一些内容。也就是对象的初始化内容。

    (2)构造函数是在对象建立时由jvm调用, 给对象初始化。一般函数是对象建立后,当对象调用该功能时才会执行。

    (3)普通函数可以使用对象多次调用,构造函数就在创建对象时调用。

    (4)构造函数的函数名要与类名一样,而普通的函数只要符合标识符的命名规则即可。

    (5)构造函数没有返回值类型。

    3.构造函数要注意的细节:

    (1)当类中没有定义构造函数时,系统会指定给该类加上一个空参数的构造函数。这个是类中默认的构造函数。当类中如果自定义了构造函数,这时默认的构造函数就没有了。

    备注:可以通过javap命令验证。

    (2)在一个类中可以定义多个构造函数,以进行不同的初始化。多个构造函数存在于类中,是以重载的形式体现的。因为构造函数的名称都相同。class Perosn{

    private int id;

    private String name;

    private int age;

    public Perosn(){

    cry();

    }

    public Perosn(int id, String name, int age) {

    this.id = id;

    this.name = name;

    this.age = age;

    }

    public int getId() {

    return id;

    }

    public void setId(int id) {

    this.id = id;

    }

    public String getName() {

    return name;

    }

    public void setName(String name) {

    this.name = name;

    }

    public int getAge() {

    return age;

    }

    public void setAge(int age) {

    this.age = age;

    }

    public void cry(){

    System.out.println("哇哇哇....");

    }

    }

    问题:要求每个小孩出生都会哭,这份代码有两个构造函数,如果需要每个小孩出生都要哭的话,那么就需要在不同的构造函数中都调用cry()函数,但是这样子的话造成了代码重复问题,那么怎么解决呢?构造代码块。

    4.构造代码块:

    构造代码块作用:给所有的对象进行统一的初始化。class Perosn{

    private int id;

    private String name;

    private int age;

    {

    cry();// 每个Person对象创建出来都会执行这里的代码

    }

    public Perosn(){

    cry();

    }

    public Perosn(int id, String name, int age) {

    this.id = id;

    this.name = name;

    this.age = age;

    }

    public int getId() {

    return id;

    }

    public void setId(int id) {

    this.id = id;

    }

    public String getName() {

    return name;

    }

    public void setName(String name) {

    this.name = name;

    }

    public int getAge() {

    return age;

    }

    public void setAge(int age) {

    this.age = age;

    }

    public void cry(){

    System.out.println("哇哇哇....");

    }

    }

    具体作用:

    1:给对象进行初始化。对象一建立就运行并且优先于构造函数。

    2:与构造函数区别

    (1)构造代码块和构造函数的区别,构造代码块是给所有对象进行统一初始化, 构造函数给对应的对象初始化。

    (2)构造代码块的作用:它的作用就是将所有构造方法中公共的信息进行抽取。

    例如孩子一出生统一哭

    代码如下:class Boy {

    String name;

    int age;

    String gender;

    // 构造代码块,给所有对象进行初始化。

    {

    System.out.println("哭。。。");

    }

    Boy() {

    System.out.println("无参构造");

    }

    Boy(String n, int a, String g) {

    name = n;

    age = a;

    gender = g;

    System.out.println("有参构造");

    }

    void run() {

    System.out.println("跑...");

    }

    }

    class Demo9 {

    public static void main(String[] args) {

    System.out.println();

    Boy b = new Boy();

    Boy b2 = new Boy("jack", 1, "男");

    }

    }

    php中文网,大量的免费Java入门教程,欢迎在线学习!

    展开全文
  • Java构造函数

    2020-01-14 10:22:31
    Java构造函数 构造函数 构造函数的最大作用就是创建对象时完成初始化,当我们在new一个对象并传入参数的时候,会自动调用构造函数并完成参数的初始化 构造函数的规则: 构造函数与类同名 每个类可以有一个以上的...

    Java构造函数

    构造函数

    构造函数的最大作用就是创建对象时完成初始化,当我们在new一个对象并传入参数的时候,会自动调用构造函数并完成参数的初始化

    构造函数的规则:

    • 构造函数与类同名
    • 每个类可以有一个以上的构造函数
    • 构造函数可以有0 个 、 1 个或多个参数
    • 构造函数没有返回值
    • 构造函数总是伴随着new操作一起调用

    看一个Employee类例子:

    public class Employee {
    
    
    //    关键字 private 确保只有 Employee 类自身的方法能够访问这些实例域 , 而其他类的方法不能够读写这些域 。
    
    //     可以用 public 标记实例域 , 但这是一种极为不提倡的做法
    //public 數据域允许程序中的任何方法对其进行读取和修改 ,。 这就完全破坏了封装 。
    //任何类的任何方法都可以修改 public 域 , 从我们的经验来看 , 某些代码将使用这种存取权限 , 而这并不我们所希
    //望的 , 因此这里强烈建议将实例域标记为 private , ,
    
        private String name ;
    
        private double salary ;
    
        public Employee(String name, double salary) {
            this.name = name;
            this.salary = salary;
        }
    
        @Override
        public String toString() {
            return "Employee{" +
                    "name='" + name + '\'' +
                    ", salary=" + salary +
                    '}';
        }
    
        public static void main(String[] args) {
    
    
    //        说明在我们创建Employee对象的时候,会自动调用构造函数完成初始化,
    
            Employee employee = new Employee("John",44545);
    
            System.out.println(employee);
    
    
        }
    }
    
    

    细节

    • 如果你不写构造函数,程序会自动给你加上一个无参数无操作的构造函数(当然你看不见)

    • 如果你写了构造函数,则自定义构造函数会覆盖无参数构造函数

    public class Employee_1 {
    
        @Override
        public String toString() {
            return "Employee_1{}";
        }
    
        public static void main(String[] args) {
    
    //        没有显式提供构造函数
            
    //        程序会自动给你加上一个无参数无操作的构造函数
            
            Employee_1 employee_1 = new Employee_1();
    
            System.out.println(employee_1);
        }
    }
    
    

    构造函数与普通函数的区别:

    • 一般函数是用于定义对象应该具备的功能。而构造函数定义的是,对象在调用功能之前,在建立时,应该具备的一些内容。也就是对象的初始化内容。

    • 构造函数是在对象建立时由JVM调用, 给对象初始化。一般函数是对象建立后,当对象调用该功能时才会执行。

    • 普通函数可以使用对象多次调用,构造函数就在创建对象时调用。

    • 构造函数的函数名要与类名一样,而普通的函数只要符合标识符的命名规则即可。

    • 构造函数没有返回值类型。

    初始化

    为什么需要初始化

    java规定,变量没有初始化不能使用,全局变量也就是类的属性,java会在编译的时候,自动将他们初始化,所以可以不进行变量初始化的操作,但是(局部)变量必须初始化

    初始化就是在最开始定义成员变量时给它一个初始的值,为了防止程序运行时候出现未知的错误,或者bug

    总之一句话,为了安全

    默认初始化

    在Java中,一个类的数据成员(成员变量)如果没有指定初始化,那么Java会对其执行默认初始化

    public class InitialValues {
    
        boolean t;
        char c;
        short s;
        int i;
        long l;
        float f;
        double d;
        String str;
        InitialValues reference;
    
        void printInitialValues() {
            System.out.printf("%-10s %-5s\n", "boolean:", t);
            System.out.printf("%-10s %-5s\n", "char:", c);
            System.out.printf("%-10s %-5s\n", "short:", s);
            System.out.printf("%-10s %-5s\n", "int:", i);
            System.out.printf("%-10s %-5s\n", "long:", l);
            System.out.printf("%-10s %-5s\n", "float:", f);
            System.out.printf("%-10s %-5s\n", "double:", d);
            System.out.printf("%-10s %-5s\n", "String:", str);
            System.out.printf("%-10s %-5s\n", "reference:", reference);
        }
    
        public static void main(String[] args) {
            InitialValues iv = new InitialValues();
            iv.printInitialValues();
        }
    
    }
    
    
    

    输出:

    boolean:   false
    char:           
    short:     0    
    int:       0    
    long:      0    
    float:     0.0  
    double:    0.0  
    String:    null 
    reference: null 
    

    静态数据的初始化

    初始化的顺序是:先静态对象,而后是“非静态”对象。

    class Bowl{
        Bowl(int marker){
            System.out.println("Bowl("+marker+")");
        }
        void f1(int marker){
            System.out.println("f1("+marker+")");
        }
    }
    
    
    class Table{
    
        static Bowl bowl1=new Bowl(1);
    
        Table(){
            System.out.println("Table()");
            bowl2.f1(1);
        }
    
    
        void f2(int marker){
            System.out.println("f2("+marker+")");
        }
    
    
        static Bowl bowl2= new Bowl(2);
    }
    
    
    class Cupboard{
    
        Bowl bowl3=new Bowl(3);
    
        static Bowl bowl4=new Bowl(4);
    
        Cupboard(){
            System.out.println("Cupboard()");
            bowl4.f1(2);
        }
    
    
        void f3(int marker){
            System.out.println("f3("+marker+")");
        }
    
    
        static Bowl bowl5= new Bowl(5);
    
    
    }
    
    public class StaticInitialization {
    
    
    //    要执行main(),必须加载StaticInitialization类,然后其静态域table和cupboard被初始化,这导致他们对应的类也被加载,并且由于它们都包含静态的Bowl对象,
    //    因此Bowl随后也被加载。这样,在这个特殊的程序中的所有的类在main()开始之前就都被加载了。
    //
    //    首先从main()函数开始,加载StaticInitializaition类,然后对StaticInitializaition类中的静态域Table进行初始化,加载Table类,Table类中包含静态的Bowl对象,
    //    接着加载Bowl类,加载Bowl类构造器创建bowl1对象,输出Bowl(1),加载Bowl类构造器创建bowl2对象,输出Bowl(2);同里创建cupboard对象。
    //
    //    需要注意的是,bowl3是非静态域,每次创建Cupboard对象都会创建一个Bowl对象。
        public static void main(String[] args) {
            System.out.println("Creating new Cupboard() in main");
            new Cupboard();
            System.out.println("Creating new Cupboard() in main");
            new Cupboard();
            table.f2(1);
            cupboard.f3(1);
        }
    
        static Table table = new Table();
        static Cupboard cupboard = new Cupboard();
    }
    
    
    

    非静态成员初始化

    在一个类中,非静态成员的初始化,发生在任何方法(包括构造器)被调用之前。并且它们定义的顺序,决定了初始化的顺序

    class A{
    
        A(String s) {
    
            System.out.println(s);
    
        }
    }
    
    class B{
    
        A a1 = new A("a1");
    
        B() {
    
            System.out.println("B");
            A a2 = new A("a2");
    
        }
    
        A a3 = new A("a3");
        void f(){
            System.out.println("f---");
        }
        A a4 = new A("a4");
    }
    
    public class Initialization_1 {
    
        public static void main(String[] args) {
    
            B b = new B();
    
            b.f();
    
        }
    
    }
    
    

    静态块代码初始化

    整个static { 静态代码块 } 可以看作是一个静态成员。当一个类需要执行静态初始化时,该类中的静态成员初始化和静态代码块,会按照先后定义的顺序执行。当然,这个流程也是就执行这一次

    class AA{
    
        public AA(String s) {
    
            System.out.println(s);
        }
    }
    
    class BB{
        AA a1 = new AA("a1");
    
        static AA a2 = new AA("a2");
    
        static AA a3,a4;
    
        static {
    
            System.out.println("______________");
    
            a3 = new AA("a3");
    
            a4 = new AA("a4");
    
            AA a5 = new AA("a5");
    
            System.out.println("++++++++++++");
    
        }
    
        static AA a6 = new AA("a6");
    
        AA a7 = new AA("a7");
    
        public BB() {
    
            System.out.println("BB");
        }
    }
    public class Initialization_3 {
    
        static BB b1 = new BB();
    
        public static void main(String[] args) {
    
            new BB();
    
        }
    
    
    }
    
    

    非静态代码初始化

    非静态代码块,可以看作一个非静态成员。涉及非静态初始化,也会执行它。和普通的非静态成员初始化一样,它的执行也发生在构造器调用之前,并且每当创建对象之前都会调用。

    
    class AA{
    
        public AA(String s) {
    
            System.out.println(s);
        }
    }
    
    class BB{
        AA a1 = new AA("a1");
    
        static AA a2 = new AA("a2");
    
        static AA a3,a4;
    
        {
    
            System.out.println("______________");
    
            a3 = new AA("a3");
    
            a4 = new AA("a4");
    
            AA a5 = new AA("a5");
    
            System.out.println("++++++++++++");
    
        }
    
        static AA a6 = new AA("a6");
    
        AA a7 = new AA("a7");
    
        public BB() {
    
            System.out.println("BB");
        }
    }
    public class Initialization_4 {
    
        static BB b1 = new BB();
    
        public static void main(String[] args) {
    
            new BB();
    
        }
    
    
    }
    
    
    

    方法重载

    如果多个方法 ( 比如 , StringBuilder构造器方法 ) 有相同的名字 、 不同的参数, 便产生了重载 。 编译器必须挑选出具体执行哪个方法 , 它通过用各个方法给出的参数类型与特定方法调用所使用的值类型进行匹配来挑选出相应的方法 。 如果编译器找不到匹配的参数 , 就会产生编译时错误, 因为根本不存在匹配 ,或者没有一个比其他的更好。( 这个过程被称为重载解析 ( overloading resolution )。

    Java 允许重载任何方法 ,而不只是构造器方法。 因此 , 要完整地描述一个方法 ,需要指出方法名以及参数类型 。 这叫做方法的签名 ( signature ) 。 例如 , String 类有 4 个称为 indexOf 的公有方法。它们的签名是

    • indexOf ( int )

    • indexOf ( int , int )

    • indexOf ( String )

    • indexOf ( String , int )

    返回类型不是方法签名的一部分 。 也就是说, 不能有两个名字相同 、参数类型也相同却返回不同类型值的方法 。

    涉及基本类型的重载

    Java中的基本类型有一个特性:它能自动从一个"较小"的类型转换成"较大"的类型!上面这句话什么意思呢?指的就是byte、char、short等"较小"类型能自动转换成int类型,而不需要额外的其他操作。因此,如果这个自动转换的过程涉及到重载,可能会造成混淆。

    “由小到大”依次为:byte->short->int->long->float->double;

    this关键字

    this:引用当前类的实例变量——解决形参和实参的重名尴尬

    this关键字可以用来引用当前类的实例变量。如果实例变量和参数之间存在歧义,则 this 关键字可用于明确地指定类变量以解决歧义问题

    先看没有使用this例子:

    
    public class Person {
    
        private int age;
    
        private String name;
    
    //    public Person(int age, String name) {
    //        this.age = age;
    //        this.name = name;
    //    }
    
        public Person(int age, String name) {
            age = age;
            name = name;
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "age=" + age +
                    ", name='" + name + '\'' +
                    '}';
        }
    
        public static void main(String[] args) {
    
            Person person = new Person(15,"John");
    
            System.out.println(person);
    
    
        }
    }
    
    
    

    输出:

    Person{age=0, name='null'}
    
    

    在上面的例子中,参数(形式参数)和实例变量(age和name)是相同的。 所以要使用this关键字来区分局部变量和实例变量。

    使用this:

    public class Person {
    
        private int age;
    
        private String name;
    
        public Person(int age, String name) {
            this.age = age;
            this.name = name;
        }
    
    //    public Person(int age, String name) {
    //        age = age;
    //        name = name;
    //    }
    
        @Override
        public String toString() {
            return "Person{" +
                    "age=" + age +
                    ", name='" + name + '\'' +
                    '}';
        }
    
        public static void main(String[] args) {
    
            Person person = new Person(15,"John");
    
            System.out.println(person);
    
    
        }
    }
    
    
    

    如果局部变量(形式参数)和实例变量不同,则不需要像下面的程序一样使用this关键字:

    
    public class Person {
    
        private int age;
    
        private String name;
    
    //    public Person(int age, String name) {
    //        this.age = age;
    //        this.name = name;
    //    }
    
    //    public Person(int age, String name) {
    //        age = age;
    //        name = name;
    //    }
    
        public Person(int the_age, String the_name) {
            age = the_age;
            name = the_name;
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "age=" + age +
                    ", name='" + name + '\'' +
                    '}';
        }
    
        public static void main(String[] args) {
    
            Person person = new Person(15,"John");
    
            System.out.println(person);
    
    
        }
    }
    
    
    

    this:调用当前类方法——对象调用方法时其实调用的this.[方法],但在实际中时隐去的

    使用this关键字调用当前类的方法。如果不使用this关键字,编译器会在调用方法时自动添加此 this 关键字

    public class Demo_1 {
    
        void f(){
            System.out.println("f_______");
        }
    
        void m(){
            f();
        }
    
        void m_1(){
            this.f();
        }
    
        public static void main(String[] args) {
    
            Demo_1 d1 = new Demo_1();
    
            d1.m();
    
            d1.m_1();
    
        }
    }
    
    

    this():调用当前类的构造函数

    this()构造函数调用可以用来调用当前类的构造函数。 它用于重用构造函数。 换句话说,它用于构造函数链接。也就是说调用一次 this(); 也就调用了一次类(其构造方法也就调用了一次类)

    class A{
    
        public A() {
            System.out.println("the a is ___");
        }
    
        public A(String name){
            this();
    
            System.out.println(name);
    
        }
    }
    public class D2 {
    
        public static void main(String[] args) {
            A a = new A("jsaksjk");
    
        }
    }
    
    

    调用this()必须是构造函数中的第一个语句

    this:作为参数传递给方法

    this关键字也可以作为方法中的参数传递

    public class D3 {
    
        void m(D3 obj) {
            System.out.println("method is invoked");
            System.out.println(obj.hashCode());
        }
    
        void p() {
            m(this);
        }
    
    
    
        public static void main(String[] args) {
    
            D3 d3 = new D3();
    
            d3.p();
    
        }
    }
    
    
    

    this:在构造函数调用中作为参数传递

    在构造函数中传递this关键字。 如果必须在多个类中使用一个对象,可以使用这种方式

    
    class DD{
    
        D4 d4;
    
        public DD(D4 d4) {
            this.d4 = d4;
        }
    
        @Override
        public String toString() {
            return "DD{" +
                    "d4=" + d4 +
                    '}';
        }
    }
    
    public class D4 {
    
        int d = 100;
    
        public D4() {
            DD dd = new DD(this);
            System.out.println(dd);
        }
    
        public static void main(String[] args) {
    
            D4 d4 = new D4();
    
        }
    }
    
    

    this关键字用来返回当前类的实例

    可以从方法中 this 关键字作为语句返回。 在这种情况下,方法的返回类型必须是类类型(非原始)

    class DDD{
    
        DDD get(){
            return this;
        }
    
        void f(){
            System.out.println("Hello World");
        }
    
    }
    public class D5 {
    
        public static void main(String[] args) {
    
            new DDD().get().f();
    
        }
    }
    
    
    展开全文
  • Java基础知识之构造函数详解2021年01月02日|萬仟网IT编程 |我要评论 构造函数这里对java构造函数进行一个详细的解答,希望对热爱java的小伙伴有帮助。提醒哦: 一定要注意构造函数的注意事项以及构造函数和普通函数...

    Java基础知识之构造函数详解

    2021年01月02日

    | 萬仟网IT编程

     | a48e1d17a2b0511faa7da7240b1971f6.png我要评论

    构造函数这里对java中构造函数进行一个详细的解答,希望对热爱java的小伙伴有帮助。提醒哦: 一定要注意构造函数的注意事项以及构造函数和普通函数的区别!!/*构造函数: 构造函数的作用: 给对应的对象进行初始化。 构造函数的定义格式: 修饰符 函数名(形式参数){ 函数体... } 构造函数要注意的细节: 1. 构造函数是没有返回值类型的。 2. 构造函数的函数名必须要与类名一致。 3. 构造函数并不是由我们手动调用的,而是在创建对应的对象时,jvm就

    构造函数

    这里对java中构造函数进行一个详细的解答,希望对热爱java的小伙伴有帮助。

    提醒哦: 一定要注意构造函数的注意事项以及构造函数和普通函数的区别!!

    /*

    构造函数:

    构造函数的作用: 给对应的对象进行初始化。

    构造函数的定义格式:

    修饰符 函数名(形式参数){

    函数体...

    }

    构造函数要注意的细节:

    1. 构造函数是没有返回值类型的。

    2. 构造函数的函数名必须要与类名一致。

    3. 构造函数并不是由我们手动调用的,而是在创建对应的对象时,jvm就会主动调用到对应的构造函数。

    4. 如果一个类没有显示的写上一个构造方法时,那么java编译器会为该类添加一个无参的构造函数。

    5. 如果一个类已经显示的写上一个构造方法时,那么java编译器则不会再为该类添加一个无参的构造方法。

    6. 构造函数是可以在一个类中以函数重载的形式存在多个的。

    疑问: 创建对象时,jvm就会调用到对应的构造方法,那么我们以前没有学构造方法,那么以前创建对象时,

    jvm是否也会调用构造方法呢?如果有?构造函数从何而来呢?

    会调用,java编译器在编译的时候给加上去的。

    疑问: java编译器添加的无参构造方法的权限修饰符是什么?

    与类的权限修饰符是一致的。

    构造函数与普通函数的区别:

    1. 返回值类型的区别:

    1. 构造函数是没有返回值类型的。

    2. 普通函数是有返回值类型的,即使函数没有返回值,返回值类型也要写上void。

    2. 函数名的区别:

    1. 构造函数的函数名必须要与类名一致。

    2. 普通函数的函数名只要符合标识符的命名规则即可。

    3. 调用方式的区别:

    1. 构造函数是在创建对象的时候由jvm调用的。

    2. 普通函数是由我们使用对象调用的,一个对象可以调用多次普通的函数。

    4. 作用上的区别:

    1. 构造函数的作用是用于初始化一个对象的。

    2. 普通函数是用于描述一类事物的公共行为的。

    */

    本文地址:https://blog.csdn.net/qq_49529322/article/details/112084268

    如您对本文有疑问或者有任何想说的,请点击进行留言回复,万千网友为您解惑!

    相关文章:

    输入一个正整数数组,把数组里所有数字拼接起来排成一个数,打印能拼接出的所有数字中最小的一个。例如输入数组{3,3...

    454. 四数相加 II题目:给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i,...

    java多个数组之间的排列组合,具体内容如下

    说明:有一批手机有各种颜色、各种尺寸、各种版本,然后要实现他们之间各种属性的组合。...

    单例模式是23中设计模式中最简单的设计模式,在企业开发中也应用的特别多。单例模式的优点是:项目中有且仅有一个实例。

    特点:构造器私...

    核心代码pom.xmlorg.springfr...

    gif;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQImWNgYGBgAAAABQABh6FO1AAAAABJRU5ErkJggg

    该文章是图说Java系列文章中的一篇 substring(int beginIndex, int endIndex)方法在jdk 6和jdk 7中的...

    gif;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQImWNgYGBgAAAABQABh6FO1AAAAABJRU5ErkJggg

    一、filter(过滤器)

    filter接口定义在javax.servlet包中,是servlet规范定义的,作用于reque...

    gif;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQImWNgYGBgAAAABQABh6FO1AAAAABJRU5ErkJggg

    你知道的越多,你不知道的越多 点赞再看,养成习惯 本文 GitHub https://github.com/JavaFamily 已收录,有一线大厂...

    归并排序就是采用分治法进行排序:

    (1)将一个数组分成小的2个数组分别进行排序;

    (2)之后将分出来的已经拍好序的数组进行合并;...

    网友评论

    387afa1e91d68b43eca6c11dc07bf577.gif

    验证码:

    753204.html

    展开全文
  • java命名规范

    千次阅读 2021-03-22 16:40:08
    一、命名规范1、 项目名全部小写2、 包名全部小写3、 类名首字母大写,如果类名由多个单词组成,每个单词的首字母都要大写。如:public class MyFirstClass{}4、 变量名、方法名首字母小写,如果名称由多个单词组成...
  • 本文主要是为新手、对java语言感兴趣的人和那些没有系统学习过java基础知识的人进行一个总结,在文章中对构造函数进行了较为详细的说明和讨论,也包含了我个人对于java面向对象中构造函数的一些看法。希望走在java...
  • Java 构造函数的详解

    万次阅读 多人点赞 2016-07-14 14:54:44
    我们人出生的时候,有些人一出生之后再起名字的,但是有些人一旦出生就已经起好名字的。那么我们在java里面怎么在对象一旦...而构造函数定义的是,对象在调用功能之前,在建立时,应该具备的一些内容。也就是对象的初
  • Java 构造函数特点

    千次阅读 2019-03-20 12:10:52
    (1). 一般函数是用于定义对象应该具备的功能。而构造函数定义的是,对象在调用功能之前,在建立时,应该具备的一些内容。... 构造函数的函数名要与类名一样,而普通的函数只要符合标识符的命名...
  • Java中的构造函数

    2021-04-23 12:38:58
    Java当中 ,构造函数一般都是创建对象时初始化对象,即为对象成员变量赋初始值,使用时必须和new运算符一起使用。构造方法的作用一:对对象进行初始化import java.io.*;public class person{String name;//名字int...
  • 1.【强制】 代码中的命名均不能以下划线或美元符号开始,也不能以下划线或美元符号结束。反例: _name / __name / $Object / name_ / name$ / Object$2.【强制】 代码中的命名严禁使用拼音与英文混合的方式,更不...
  • 今天在JAVA的研究学习当中发现了构造函数这个神奇但是麻烦的东西, 他在给我感觉很像OC语言中的initWith…, 但是在细节上有很多的不同, 而代码块这个东西更是让我这个敲iOS的眼前一亮, 后来针对代码块这个东西的功能...
  • 今天来梳理一下java中的方法方法定义方法重载构造函数方法定义定义:可以简单的理解为:一个模型的功能,一个对象的行为,一个function(函数)方法分类“1. 返回值为空void的方法public void m1() {方法体}2. 带具体...
  • Java命名规范

    2021-03-16 17:30:03
    一、命名规范1、项目名全部小写2、包名全部小写3、类名首字母大写,如果类名由多个单词组成,每个单词的首字母都要大写。如:public class MyFirstClass{}4、变量名、方法名首字母小写,如果名称由多个单词组成,每...
  • //: c07:Sandwich.java// Order of constructor calls.// package c07;// import com.bruceeckel.simpletest.*;import java.util.*;class Meal {Meal() { System.out.println("Meal()"); }}class...
  • 构造函数--Java基础039

    2021-03-14 10:40:06
    /*构造函数的作用: 给对应的对象进行初始化。构造函数的定义的格式:修饰符 函数名(形式参数){函数体...}构造函数要注意的细节:1. 构造函数 是没有返回值类型的。2. 构造函数的函数名必须要与类名一致。3. 构造...
  • 我们人出生的时候,有些人一出生之后再...那么我们在java里面怎么在对象一旦创建就赋值呢? public class Person { String name; // 姓名 int age; // 年龄 public static void main(String[] args) ...
  • Java 构造函数总结

    2020-03-27 17:54:16
    构造函数的作用: 给对应的对象进行初始化。 构造函数的定义的格式: 修饰符 函数名(形式参数){ ...如果一个类没有显式的写上一个构造方法时,那么java编译器会为该类添加一个无参的构造函数的。 如果...
  • java - 访问匿名类的构造函数假设我有一个具体的类Class1,我正在创建一个匿名类。Object a = new Class1(){void someNewMethod(){}};现在有什么办法可以重载这个匿名类的构造函数。 如下图所示Object a = new Class...
  • Java 构造函数

    2020-04-21 08:54:26
    2.构造函数与普通函数的区别: (1). 一般函数是用于定义对象应该具备的功能。而构造函数定义的是,对象在调用功能之前,在建立时,应该具备的一些内容。也就是对象的初始化内容。 (2). 构造函数是在对象建立时由...
  • 1.构造函数(Constructor)定义格式: 访问控制符(public等)+方法名(必须和类名一致)+...(2)在命名规则上,构造函数一般是首字母大写,普通函数遵照小驼峰式命名法。 (3)构造函数不能被直接调用,必须通过n...
  • 一、构造器(构造方法|构造函数)在创建对象时...构造函数是定义在 Java类中的一个用来初始化对象的函数。构造函数与类同名且没有返回值。例如: Person类的构造函数:public class Person {int id; int age; Perso...
  • 目录 this关键字 构造函数 ...(3)this调用本类中的其他构造函数,调用时要放在构造函数的第一行 1、成员变量和方法的形参名字重名,用this来区分 public class Student { private int a...
  • Java 与 Javescript 的构造函数区别 众所周知 java与 javascript其实是两种不同的语言 java是一种引用广泛的语言而javascript则是一种脚本语言 。之间的区别之前没有太多理解因为学习尚浅且两者又都是面向对象,...
  • java构造函数

    2017-11-27 12:11:08
    java构造函数
  • 构造函数(JAVA)

    2019-09-22 00:57:44
    构造函数 :是一种特殊的方法,主要用来在创建对象时初始化对象, 即为对象成员变量赋初始值,总与new运算符一起使用在创建对象的语句中。...(在java中普通函数可以和构造函数同名,但是必须带有返回值)  ...
  • Java 带参数的构造函数

    千次阅读 2021-03-01 07:17:50
    Java 带参数的构造函数接下来,我们准备为大家介绍“带参数的构造函数”。那么,我们为什么要使用带有参数的构造函数呢?首先,我们可以举一个例子,例如:在一个游戏里面,假设它有多个不同类型的角色,而不同的...
  • 构造函数及其应用

    2020-08-01 17:53:04
    构造函数 构造函数,顾名思义构造某个事物的函数,该事物就是对象。构造函数是用来构造对象的函数。 JavaScript 中没有单独的构造函数,只是人为的把这种使用new关键字调用的函数称作构造函数,我们也可以认为凡是...
  • 1.封装的原理 : 成员变量默认只能被当前的类访问,其它类则无权访问. 对内开放,对外保护.  不要将数据暴露在外面, 将成员变量使用 private 进行修饰.私有化.  提供公共的接口方法给外界访问...."命名规范:" 1) s

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 70,729
精华内容 28,291
关键字:

java构造函数命名规则

java 订阅