构造的详解

构造的定义

在一个类中的定义的方法如果同时满足以下3个条件,该方法称为构造方法,具体如下

1. 方法名与类名相同
2. 在方法名的前面没有返回值类型的声明
3. 在方法中不能使用return语句返回一个值,但是可以单独写return语句来作为方法的结束

例 如：

public class Example05 {
    public static void main(String[] args) {
        Person person = new Person();
    }
}
class Person{
    public Person() {
        System.out.println("无参构造方法被调用了...");
    }
}

一个类中除了定义无参的构造外方法,还可以定义有参的构造方法,通过有参的构造方法就可以实现对属性的赋值

public class Example06 {
    public static void main(String[] args) {
        Person1 p = new Person1(20);
        p.show();
    }
}
class Person1 {
    int age;
    //定义有参的构造方法
    public Person1(int a) {
        age=a;    //age为a的赋值
    }
    public void show() {
        System.out.println("我今年已经"+age+"岁了");
    }
}

构造方法的重载

在一个类中可以定义多个构造方法,只要每个构造方法的参数类型或参数的个数不同即可。在创建对象时,可以通过调用不同的构造方法为不同的属性进行赋值。

class Person{
    String name;
    int age;
    public Person(String con_name, int con_age) {
        name = con_name;            //为name属性赋值
        age = con_age;                //为age属性赋值
    }
    public Person(String con_name) {
        name = con_name;            //为name属性赋值
    }
    public void show() {
        //同时打印name和age的值
        System.out.println("大家好,我叫"+name+",我今年"+age+"岁了");
    }
}
public class Example07 {

    public static void main(String[] args) {
        //分别创建两个对象ps1和ps2
        Person ps1 = new Person("小明");
        Person ps2 = new Person("小红", 18);
        //通过对象ps1和ps2调用show()方法
        ps1.show();
        ps2.show();
    }
}

this关键字

Java中提供了一个关键字this来指代当前对象,用于在方法中访问对象的其他成员

1. 通过this关键字可以明确地区访问一个类的成员变量,解决与局部变量的名称冲突问题，在构造方法中如果使用"age"，则是访问局部变量,但如果使用"this.age"则是访问成员变量

public class this01 {
    int age;
    public this01(int age) {
        this.age = age;
    }
    public int getAge() {
        return this.age;
    }
}

2. 通过this调用成员方法,可以省略不写

public class this02 {
    public void openMouth() {
    }
    public void show() {
        this.openMouth();
    }
}

3. 可以在一个构造方法中使用"this([参数1]，[参数2]...)"的形式去调用其他的构造方法

class Person{
    public Person() {
        System.out.println("无参构造方法被调用了...");
    }
    public Person(String name) {
        this();
        System.out.println("有参构造方法被调用了");
    }
}
public class this03{
    public static void main(String[] args) {
        Person p = new Person("hahaha");
    }
}

在使用this调用类的构造方法时,应该注意以下几点：

1. 只能在构造方法中使用this调用其他构造方法,不能在成员方法中使用
2. 在构造方法中,使用this调用构造方法的语句必须位于第一行,且只能出现一次
3. 不能在一个类的两个构造方法中使用this相互调用

static关键字

在定义一个类时,只是在描述某类事物的特征和行为,并没有产生具体的数据。只有通过new关键字创建该类的实例对象后,系统才会为每个对象分配空间,存储各自的数据。
在一个Java类中,可以使用static关键字来修饰成员变量,该变量被称作静态变量，静态变量被所有实例共享，可以使用 "类名.变量名" 的形式来访问。

class Student{
    static String schoolName;
}
public class Example12 {
    public static void main(String[] args) {
        Student stu1 = new Student();
        Student stu2 = new Student();
        Student.schoolName="黄冈科技";
        //打印第一个对象的学校
        System.out.println("第一个对象的学校是"+stu1.schoolName);
        System.out.println("第二个对象的学校是"+stu2.schoolName);
    }
}

注 意 :

static关键字只能用于修饰称成员变量,不能用于修饰局部变量,否则会报错

静态方法

静态方法可以在不创建对象的情况下直接调用,使用static修饰,称为静态方法,使用 "类名.方法名" 来访问

class Person{
    public static void sayHello() {    //定义静态方法
        System.out.println("hello");
    }
}
public class Example13 {
    public static void main(String[] args) {
        //1.类名.方法名的方式调用静态方法
        Person.sayHello();
        //2.实例化对象的方式来调用静态方法
        Person p = new Person();
        p.sayHello();
    }
}

注 意 :

在一个静态方法中只能访问static修饰的成员,原因在于没有被static修饰的成员需要先创建对象才能访问，而静态方法被调用时可以不创建任何对象。

public class Example14 {
    static {
        System.out.println("测试类的静态代码块执行了");
    }
    public static void main(String[] args) {
        //创建两个Person类对象  但是静态代码块只会执行一次
        Person1 p1 = new Person1();
        Person1 p2 = new Person1();
    }
}
class Person1{
    static {
        System.out.println("Person的静态代码块");
    }
}

成员内部类

在一个类中除了可以定义成员变量、成员方法外，还可以定义类，这样的类被称为成员内部类。在成员内部类中，可以访问外部类的所有成员。

class Outer{
    private int num=4;   //定义类的成员变量
    //定义一个成员方法,方法中访问内部类
    public void test() {
        Inner inner = new Inner();
        inner.show();
    }
    class Inner{
        public void show(){
            //在成员内部类的方法中访问外部类的成员变量
            System.out.println("num="+num);
        }
    }
}
public class Example15 {
    public static void main(String[] args) {
        Outer outer = new Outer();         //创建外部类对象
        outer.test();    //调用test方法
    }
}

如果想通过外部类去访问内部类,则需要通过外部类对象去创建内部类对象，创建内部类对象的具体语法格式如下:

外部类名.内部类名 变量名 = new 外部类名().new 内部类名 ()

示 例：

public class Example16 {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer().new Inner();   //创建内部类对象
        inner.show();
    }
}