200-Java语言基础-Java编程入门-008 | Java面向对象（二）- 构造器、成员变量、静态

一、构造方法Constructor概述和格式
构造方法概述和作用：
  • 给对象的数据(属性)进行初始化
构造方法格式特点：
  • 方法名与类名相同(大小也要与类名一致)
  • 没有返回值类型，连void都没有
  • 没有具体的返回值return;
 1 class JavaDemo {
 2   public static void main(String[] args) {
 3     Person p = new Person();          // 在一创建对象的时候，系统就帮我们调用了构造方法
 4     // p.Person();                    // 构造方法不能用对象调用
 5     p.show();
 6   }
 7 }
 8 /*
 9 * A:构造方法概述和作用
10    * 给对象的数据(属性)进行初始化
11 * B:构造方法格式特点
12    * a:方法名与类名相同(大小也要与类名一致)
13    * b:没有返回值类型，连void都没有
14    * c:没有具体的返回值return;
15 */
16 class Person {
17   // 成员变量
18   private String name;
19   private int age;
20   
21   // 构造方法
22   public Person() {
23     // System.out.println("hello world");
24     // return;                        // 构造方法也是有return语句的，格式是return;
25     // 给对象的数据(属性)进行初始化
26     name = "张三";
27     age = 23;
28   }
29   
30   public void show() {
31     System.out.println(name + "..." + age);
32   }
33 }
 
二、构造方法的重载及注意事项
构造方法注意事项：
  • 如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
  • 如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
    • 注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法
 1 class JavaDemo {
 2   public static void main(String[] args) {
 3     Person p1 = new Person();          // 在一创建对象的时候，系统就帮我们调用了构造方法
 4     p1.show();
 5     System.out.println("------------");
 6     Person p2 = new Person("张三", 23);
 7     p2.show();
 8     System.out.println("------------");
 9     Person p3 = new Person("李四", 24);
10     p3.show();
11   }
12 }
13 /*
14 * A:案例演示
15    * 构造方法的重载
16    * 重载:方法名相同,与返回值类型无关(构造方法没有返回值),只看参数列表
17 * B:构造方法注意事项
18    * a:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
19    * b:如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
20      * 注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法
21 */
22 class Person {
23   // 成员变量
24   private String name;
25   private int age;
26   
27   // 空参构造方法
28   public Person() {
29     System.out.println("空参的构造");
30   }
31   
32   //有参构造方法
33    public Person(String name, int age) {
34      this.name = name;
35      this.age = age;
36      System.out.println("有参的构造");
37    }
38   
39   public void show() {
40     System.out.println(name + "..." + age);
41   }
42 }
 
三、给成员变量赋值的两种方式的区别
setXxx()方法：
  • 修改属性值
构造方法：
  • 给对象中属性进行初始化
 1 class JavaDemo {
 2   public static void main(String[] args) {
 3     // 有参构造创建对象
 4     Person p1 = new Person("张三", 23);
 5     // 这种方法看运行结果貌似是改名了，其实是将原对象变成了垃圾（不推荐）
 6     p1 = new Person("张三丰", 23);
 7     System.out.println(p1.getName() + "..." + p1.getAge());
 8     System.out.println("------------");
 9     
10     // 空参构造创建对象
11     Person p2 = new Person();
12     p2.setName("李四");
13     p2.setAge(24);
14     
15     p2.setName("李四囍");
16     System.out.println(p2.getName() + "..." + p2.getAge());
17   }
18 }
19 /*
20 * A:构造方法：
21    * 给属性进行初始化
22 * B:setXxx()方法
23    * 修改属性值
24    * 这两种方式，在开发中使用setXxx()方法更多一些，比较灵活
25 */
26 class Person {
27   // 成员变量
28   private String name;
29   private int age;
30   
31   // 空参构造方法
32   public Person() {
33     
34   }
35   
36   //有参构造方法
37    public Person(String name, int age) {
38      this.name = name;
39      this.age = age;
40    }
41   
42   public String getName() {
43     return name;
44   }
45   public void setName(String name) {
46     this.name = name;
47   }
48   public int getAge() {
49     return age;
50   }
51   public void setAge(int age) {
52     this.age = age;
53   }
54   public void show() {
55     System.out.println(name + "..." + age);
56   }
57 }
 
四、面向对象代码小结
1、学生类的代码及测试
 1 /*
 2 * A:案例演示
 3    * 学生类：
 4      * 成员变量：
 5        * name，age
 6      * 构造方法：
 7        * 无参，带两个参
 8      * 成员方法：
 9        * getXxx()/setXxx()
10        * show()：输出该类的所有成员变量值
11 * B:给成员变量赋值：
12    * a:setXxx()方法
13    * b:构造方法
14   
15 * C:输出成员变量值的方式：
16    * a:通过getXxx()分别获取然后拼接
17    * b:通过调用show()方法搞定
18 */
19 class JavaDemo {
20   public static void main(String[] args) {
21     // 空参构造创建对象
22     Student stu = new Student();
23     stu.setName("张三");
24     stu.setAge(23);
25     System.out.println(stu.getName() + "..." + stu.getAge());
26     System.out.println("----------");
27     // 有参构造创建对象
28     Student stu1 = new Student("张三丰", 23);
29     stu1.show();
30   }
31 }
32 class Student {
33   // 成员变量
34   private String name;
35   private int age;
36   
37   // 空参构造方法
38   public Student() {
39     
40   }
41   
42   //有参构造方法
43    public Student(String name, int age) {
44      this.name = name;
45      this.age = age;
46    }
47   
48   public String getName() {
49     return name;
50   }
51   public void setName(String name) {
52     this.name = name;
53   }
54   public int getAge() {
55     return age;
56   }
57   public void setAge(int age) {
58     this.age = age;
59   }
60   public void show() {
61     System.out.println(name + "..." + age);
62   }
63 }
 
五、创建一个对象的步骤
画图说明一个对象的创建过程做了哪些事情?
  • Student s = new Student();
  • Student.class加载进内存
  • 声明一个Student类型引用s
  • 在堆内存创建对象,
  • 给对象中属性默认初始化值
  • 属性进行显示初始化
  • 构造方法进栈,对对象中的属性赋值,构造方法弹栈
  • 将对象的地址值赋值给s
 
六、static关键字及内存图
 1 class JavaDemo {
 2   public static void main(String[] args) {
 3     // 创建对象
 4     Person p1 = new Person();
 5     // 调用姓名属性并赋值
 6     p1.name = "特朗普";
 7     // 调用国籍属性并赋值
 8     p1.country = "美国";
 9     p1.speak();
10     
11     // 创建对象
12     Person p2 = new Person();
13     // 调用姓名属性并赋值
14     p2.name = "奥巴马";
15     p2.speak();
16   }
17 }
18 class Person {
19   // 成员变量
20   String name;       // 姓名
21   static String country;    // 国籍
22   
23   public void speak() {
24     System.out.println(name + "..." + country);
25   }
26 }
1、static关键字的特点
static关键字的特点：
  • 随着类的加载而加载
  • 优先于对象存在
  • 被类的所有对象共享
    • 举例：咱们班级的学生应该共用同一个班级编号。
    • 其实这个特点也是在告诉我们什么时候使用静态?
      • 如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。
    • 举例：
      • 饮水机(用静态修饰)
      • 水杯(不能用静态修饰)
      • 共性用静态,特性用非静态
  • 可以通过类名调用
    • 其实它本身也可以通过对象名调用。
    • 推荐使用类名调用。
    • 静态修饰的内容一般我们称其为：与类相关的，类成员
 1 class JavaDemo {
 2   public static void main(String[] args) {
 3     // 创建对象
 4     Person p1 = new Person();
 5     /*
 6     // 调用姓名属性并赋值
 7     p1.name = "特朗普";
 8     // 调用国籍属性并赋值
 9     p1.country = "美国";
10     p1.speak();
11     
12     // 创建对象
13     Person p2 = new Person();
14     // 调用姓名属性并赋值
15     p2.name = "奥巴马";
16     p2.speak();
17     */
18     // 静态多了一种调用方式，可以通过类名.
19     Person.country = "美国";
20     System.out.println(Person.country);
21   }
22 }
23 class Person {
24   // 成员变量
25   String name;       // 姓名
26   static String country;    // 国籍
27   
28   public void speak() {
29     System.out.println(name + "..." + country);
30   }
31 }
 
2、static的注意事项
static的注意事项：
  • 在静态方法中是没有this关键字的
    • 静态是随着类的加载而加载，this是随着对象的创建而存在。
    • 静态比对象先存在
  • 静态方法只能访问静态的成员变量和静态的成员方法
    • 静态方法：
      • 成员变量：只能访问静态变量
      • 成员方法：只能访问静态成员方法
    • 非静态方法：
      • 成员变量：可以是静态的，也可以是非静态的
      • 成员方法：可是是静态的成员方法，也可以是非静态的成员方法。
 1 class JavaDemo {
 2   public static void main(String[] args) {
 3     Demo d1 = new Demo();
 4     d1.print1();
 5     
 6     Demo.print2();
 7   }
 8 }
 9 /*
10 * A:static的注意事项
11    * a:在静态方法中是没有this关键字的
12      * 如何理解呢?
13        * 静态是随着类的加载而加载，this是随着对象的创建而存在。
14        * 静态比对象先存在。
15    * b:静态方法只能访问静态的成员变量和静态的成员方法
16      * 静态方法：
17        * 成员变量：只能访问静态变量
18        * 成员方法：只能访问静态成员方法
19      * 非静态方法：
20        * 成员变量：可以是静态的，也可以是非静态的
21        * 成员方法：可是是静态的成员方法，也可以是非静态的成员方法。
22      * 简单记：
23        * 静态只能访问静态。
24 */
25 class Demo {
26   // 非静态成员变量
27   int num = 10;
28   // 静态成员变量
29   static int num1 = 20;
30   
31   // 非静态的成员方法，既可以方位静态的也可以访问非静态的
32   public void print1() {
33     System.out.println(num);
34     System.out.println(num1);
35   }
36     
37   //静态的成员方法
38    public static void print2() {
39      // 静态的成员方法不能访问非静态的，错误Cannot make a static reference  to the non-static field num
40      System.out.println(num);
41      System.out.println(num1);
42    }
43 }
 
七、静态变量和成员变量的区别
静态变量也叫类变量  成员变量也叫对象变量
  • 所属不同
    • 静态变量属于类，所以也称为为类变量
    • 成员变量属于对象，所以也称为实例变量(对象变量)
  • 内存中位置不同
    • 静态变量存储于方法区的静态区
    • 成员变量存储于堆内存
  • 内存出现时间不同
    • 静态变量随着类的加载而加载，随着类的消失而消失
    • 成员变量随着对象的创建而存在，随着对象的消失而消失
  • 调用不同
    • 静态变量可以通过类名调用，也可以通过对象调用
    • 成员变量只能通过对 象名调用
 
八、main方法的格式详细解释
格式：
  • public static void main(String[] args) {}
 1 class JavaDemo {
 2   public static void main(String[] args) {
 3     /*
 4      * public：被JVM调用，所以权限要足够大
 5      * static：被JVM调用，不需要创建对象，直接类名.调用即可
 6      * void：被JVM调用，不需要任何的返回值
 7      * main：只有这样写才能被JVM调用识别，main不是关键字
 8      * String[] args：以前是用来接收键盘录入的
 9      */
10     System.out.println(args.length);
11     for (int i = 0; i < args.length; i++) {
12       System.out.println(args[i]);
13     }
14   }
15 }
 
九、工具类中使用静态
 1 public class JavaDemo {
 2   public static void main(String[] args) {
 3     int arr[] = {11, 22, 33, 44, 55, 66};
 4     /*
 5     ArrayTool at = new ArrayTool();
 6     int max = at.getMax(arr);
 7     System.out.println(max);
 8     System.out.println("--------");
 9     at.print(arr);
10     System.out.println();
11     System.out.println("--------");
12     System.out.println("反转后：");
13     at.revArray(arr);
14     at.print(arr);
15     */
16     ArrayTool.print(arr);
17   }
18 }
19 /*
20   * 1,获取最大值
21   * 2,数组的遍历
22   * 3,数组的反转
23 */
24 class ArrayTool {
25   // 如果一个类中所有的方法都是静态的，需要再多做一步,私有构造方法，目的是不让其他类创建本类对象
26   // 直接用类名.调用静态方法即可
27   private ArrayTool() {}
28   
29   // 获取最大值
30   public static int getMax(int[] arr) {
31     // 记录第一个元素
32     int max = arr[0];
33     // 从第二个元素遍历
34     for (int i = 1; i < arr.length; i++) {
35       // max与数组中其他的元素比较
36       if(max < arr[i]) {
37         // 记录较大的值
38         max = arr[i];
39       }
40     }
41     // 将最大值返回
42     return max;
43   }
44   
45   // 数组的遍历
46   public static void print(int[] arr) {
47     // 遍历数组
48     for (int i = 0; i < arr.length; i++) {
49       System.out.print(arr[i] + " ");
50     }
51   }
52   
53   // 数组的反转
54   public static void revArray(int[] arr) {
55     // 循环次数是元素个数的一半
56     for (int i = 0; i < arr.length / 2; i++) {
57       int temp = arr[i];
58       arr[i] = arr[arr.length - 1 - i];
59       arr[arr.length - 1 - i] = temp;
60     }
61   }
62 }
 
十、文档说明书的制作过程
对工具类加入文档注释
通过javadoc命令生成文档说明书：
  • @author(提取作者内容)
  • @version(提取版本内容)
  • javadoc -d 指定的文件目录 -author -version ArrayTool.java
  • @param 参数名称//形式参数的变量名称@return 函数运行完返回的数据
javadoc -d api -version -author ArrayTool.java
 1 /**
 2   * 这是一个数组工具类，里面封装了
 3   * 1,获取最大值
 4   * 2,数组的遍历
 5   * 3,数组的反转
 6   * @author sujian
 7   * @version v1.0
 8 */
 9 public class ArrayTool {
10   // 如果一个类中所有的方法都是静态的，需要再多做一步,私有构造方法，目的是不让其他类创建本类对象
11   // 直接用类名.调用静态方法即可
12   private ArrayTool() {}
13   
14   /**
15    * 这是获取数组中最大值的方法
16    * @param arr 接收一个int[]
17    * @return 返回数组中的最大值
18    */
19   // 获取最大值
20   public static int getMax(int[] arr) {
21     // 记录第一个元素
22     int max = arr[0];
23     // 从第二个元素遍历
24     for (int i = 1; i < arr.length; i++) {
25       // max与数组中其他的元素比较
26       if(max < arr[i]) {
27         // 记录较大的值
28         max = arr[i];
29       }
30     }
31     // 将最大值返回
32     return max;
33   }
34   
35   /**
36    * 这是数组的遍历的方法
37    * @param arr 接收一个int[]
38    */
39   // 数组的遍历
40   public static void print(int[] arr) {
41     // 遍历数组
42     for (int i = 0; i < arr.length; i++) {
43       System.out.print(arr[i] + " ");
44     }
45   }
46   
47   /**
48    * 这是数组的反转的方法
49    * @param arr 接收一个int[]
50    */
51   // 数组的反转
52   public static void revArray(int[] arr) {
53     // 循环次数是元素个数的一半
54     for (int i = 0; i < arr.length / 2; i++) {
55       int temp = arr[i];
56       arr[i] = arr[arr.length - 1 - i];
57       arr[arr.length - 1 - i] = temp;
58     }
59   }
60 }
 
 
 
 
 
 
 
 
posted @ 2021-03-15 10:46  sftp  阅读(91)  评论(0)    收藏  举报