java中的构造方法

构造方法：

构造方法 又称之为构造函数/构造器
1.适用性：在创建类对象时，可以快速的实现给成员变量赋值的操作。
2.定义：名字与类名相同，后面加上小括号花括号。(注意：没有返回值类型那一说，也就是不能添加返回值类型！)
3.作用：用来创建对象的必要语法。现象：如果类中不明确写构造方法的话，系统会自动提供一个‘默认的构造方法(无参数的构造方法)。构造方法在类被创建对象时会被(调用)执行！
4.注意：如果类中写了有参数的构造方法 ，系统则不再默认赠送无参数的构造方法了！
5.构造方法重载：参数个数 或参数类型不同时，名字要相同，则可构建成构造方法的重载！

package oo.day01;
​
/**
 * 学生类：代表所有学生对象的模板
 * 类中存放所有学生对象共有的属性和行为
 */
public class Student {
    //属性
    String name;//名字   ----成员变量
    int age;//年龄
    int stuID;//学号
​
    //构造方法  名字要与类名相同
    Student(String name1, int age1, int stuID1) { //有参数的构造方法  在类被创建对象时自动调用
        name = name1;
        age = age1;
        stuID = stuID1;
    }
    //------------------------
    //行为
    void study() {//学习
        System.out.println(name + "在学习....");
    }
​
    void sayHi() {//打招呼
        System.out.println("大家好，我叫" + name + ",今年已经" + age + "岁了！我的学号：" + stuID);
    }
​
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

测试类中：

package oo.day01;
​
/**
 * 学生的测试类：
 */
public class StudentTest {
    public static void main(String[] args) {
        //创建一个学生类对象
        //类型    变量名    =   创建对象的语法（new 类型()）
        Student  zs  = new Student("张三",18,1001);//创建一个学生对象 zs
        //zs这个变量能打点调用什么，取决于当前zs这个变量类型有什么
        zs.study();  //调用zs这个对象的学习方法
        zs.sayHi();  //调用zs这个对象的打招呼方法
​
        Student ls = new Student("李四",34,1005);
        ls.study();
        ls.sayHi();
​
​
        //----------------------------------
//        Student ls = new Student();
//        ls.name = "李四";
//        ls.age = 30;
//        ls.stuID = 2001;
//        ls.study();//调用ls这个对象的学习方法！
//        ls.sayHi();//调用ls这个对象的打招呼的方法！
        //总结：哪个对象打点调用方法，那么方法里面用的数据就是那个对象的！
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

this关键字

this指代的就是当前对象,可以通过this明确调用成员的内容。
哪个对象打掉调用方法，那么this指代的就是那个对象。
Java规定：成员变量与局部变量是可以同名的！在使用变量时，遵循就近原则。
如果想要明确表示当前成员变量，可以通过this关键字来明确访问。

package oo.day01;
​
/**
 * 学生类：代表所有学生对象的模板
 * 类中存放所有学生对象共有的属性和行为
 */
public class Student {
    //属性
    String name;//名字   ----成员变量
    int age;//年龄
    int stuID;//学号
​
    //构造方法  名字要与类名相同
    Student(String name, int age, int stuID) { //有参数的构造方法  在类被创建对象时自动调用
        this.name = name;
        this.age  = age;
        this.stuID = stuID;
    }
    //构造方法的重载
    Student(){//无参数的构造方法
​
    }
​
    //------------------------
    //行为
    void study() {//学习
​
        System.out.println(name + "在学习....");//this是一个隐式的写法
    }
    void sayHi() {//打招呼
        System.out.println("大家好，我叫" + this.name + ",今年已经" + this.age + "岁了！我的学号：" + this.stuID);
    }
​
}
-----------------------------------------------
    
   Student zs = new Student();
   Student ls = new Student(); 
   Student ww = new Student();
    
   zs.study();  --------------this 指代的就是zs这个对象
   ls.study();  --------------this 指代的就是ls这个对象
   ww.study();  --------------this 指代的就是ww这个对象
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

自定义类是引用数据类型！引用类型的默认值是null(空)！
如果拿一个空的引用类型变量，访问成员，则会报空指针异常:NullPointerException。
JVM(java虚拟机)分配内存：栈区 、堆区 、方法区(后续会详细讲！)
基本数据类型变量在内存中存的是数据。
引用数据类型变量在内存中存的是地址(引用)。
1.栈区：用来存放局部变量的地方,局部变量指的就是方法中声明的变量。特性：若方法执行完毕，对应的局部变量则也会一并被销毁。
2.堆区：用来存放对象的区域，当new对象时，会将对象分配到堆区。特性：如果堆区的对象没有被使用(引用)，则会变为内存垃圾，系统会自动会进行回收。（GC垃圾回收器）

基本数据类型数组在内存中的分配：

   //基本数据类型数组
        int[] arr = new int[3];//在内存中创建一块地 分了3份,每份都是int类型
        arr[0]  = 100;
        arr[1]  = 50;
        arr[2]  = 25;
//        System.out.println(arr[0]);//100
//        System.out.println(arr[1]);
//        System.out.println(arr[2]);
引用数据类型数组在内存中的分配：
//-----引用类型数组-----------------------
Student[] stus = new Student[3];
stus[0] = new Student();//先创建对象
stus[0].name = "正宇";
stus[0].age = 18;
stus[0].stuID = 1006;
System.out.println(stus[0]);
System.out.println(stus[0].name);
System.out.println(stus[0].age);
System.out.println(stus[0].stuID);
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

问题：当前项目7个类，若被创建对象时，需要依次打点调用为具体的对象初始化数据，非常麻烦。
解决：为7个类添加构造方法。

战舰类：
      Battleship() {
        x = 270;//初始x 的位置
        y = 124;// 初始y 的位置
        width = 66;//图片的宽
        height = 26;//图片的高
        speed = 20;// 步长
        life = 5;//初始 生命 5
    }
深水炸弹：
     Bomb(int x,int y){
        this.x = x;//由具体被创建对象时确定x坐标
        this.y = y;//由具体被创建对象时确定y坐标
        width = 9;//图片宽
        height = 12;//图片高
        speed = 3;//速度
    }
水雷：
 Mine(int x , int y){
        this.x = x;
        this.y = y;
        width = 11;//图片宽
        height = 11;//图片高
        speed = 2;//移动的速度
    }
鱼雷:
 Torpedo(int x, int y) {
        this.x = x;
        this.y = y;
        width = 5;//图片的宽
        height = 18;//图片的高
        speed = 2;//速度
    }
水雷潜艇：
    
    MineSubmarine(){
        width = 63;//图片的宽
        height = 19;//图片的高
        x = -width;//负一个图片的宽
        // 随机数 * (最大值- 最小值) + 最小值
        y = (int)(Math.random() *(479- height - 150) +150);//随机 y坐标
        speed = (int)(Math.random()*(3-1)+1);//随机速度
    }
鱼雷潜艇：
     TorpedoSubmarine(){
        width = 64;//图片的宽
        height = 20;//图片的高
        x = -width;//负一个图片的宽
        // 随机数 * (最大值- 最小值) + 最小值
        y = (int)(Math.random() *(479- height - 150) +150);//随机 y坐标
        speed = (int)(Math.random()*(3-1)+1);//随机速度
    }
侦察潜艇：
      ObserverSubmarine(){
        width = 63;//图片的宽
        height = 19;//图片的高
        x = -width;//负一个图片的宽
        // 随机数 * (最大值- 最小值) + 最小值
        y = (int)(Math.random() *(479- height - 150) +150);//随机 y坐标
        speed = (int)(Math.random()*(3-1)+1);//随机速度
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

问题：除了战舰，我们其它的类都会存在多个对象，那么如何表示同一类型的多个？
解决：可以用数组解决，同一类型多个的问题。

在GameWorld类上面：

Battleship ship;//声明一个战舰类型的变量
Bomb[] bombs; //声明一个深水炸弹数组的变量
MineSubmarine[] ms;//声明一个水雷潜艇数组的变量
TorpedoSubmarine[] ts;//声明一个鱼雷潜艇数组的变量
ObserverSubmarine[] os;//声明一个侦察潜艇数组的变量
Mine[] m;//声明一个水雷数组的变量
Torpedo[] t;//声明一个鱼雷数组的变量
1
2
3
4
5
6
7
8
9

问题：7个类，类中都存在重复的属性！代码冗余！
解决：需要使用继承来解决！