带你走进java-第六章.面向对象之类: 构造方法(有参与无参),静态变量,静态方法,main方法解析,面向对象的思维

类之构造方法(对成员变量进行初始化)

1.构造方法(对成员变量进行初始化):由系统调用,每创建一次对象,只调用一次

类的书写顺序:
    1.成员变量(私有化:只有本类能调用)
    2.构造方法
    3.set/get方法(访问私有化成员变量)
    4.成员方法

// 举例:  车类
//       名字
//       颜色
//       介绍自己的方法

// 成员变量私有化
// 提供set/get方法*/

class Car{
    // 成员变量
    private String name;
    private String color;

    // 构造方法(无参数类型)
    public Car(){
        // 对成员变量进行初始化
        this.name = "大众";
        this.color = "red";
        System.out.println("我是无参数 构造方法");
    }
    // 构造方法(有参数类型: 创建对象时,可以直接给成员变量赋值)
    // 构造方法的重载
    public Car(String name,String color){
        // 防止就近原则
        this.name = name;
        this.color = color;
        System.out.println("我是有参数 构造方法");
    }

    // set/get方法
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public String getColor() {
        return color;
    }

    // 成员方法
    public void sayHi() {
        System.out.println(name);
        System.out.println(color);
    }
}

// 调用Car类,生成对象
public class Demo01 {
    public static void main(String[] args) {
        // 构造方法 是由系统调用的
        // 注意: 每创建一个对象,构造方法只会调用一次
        Car c1 = new Car();
        c1.sayHi();
        // 系统会根据你传入的参数
        // 选择调用哪个构造方法
        Car c2 = new Car("兰博基尼","亮黑");
        c2.sayHi();
    }
}

2.无参数的构造方法 与 有参数的构造方法的区别
 1️⃣如果你不给无参的构造方法,系统会为你提供一个无参的构造方法(默认引用类型为null,基本数据类型为 0)
 2️⃣如果你写了有参的构造方法,那系统就不会再提供无参的构造方法.
 3️⃣所以我们一般手写类时: 会同时手写 无参和有参的构造函数

public class Demo {
    public static void main(String[] args) {
        // 创建对象时 没有给参数,所以调用的是无参的构造函数
        Phone p1 = new Phone();
        p1.sayHi();
    }
}

class Phone{
    private String name; 

    // ph快速提示
    // 无参
    public Phone() {

    }

    // 有参的构造方法
    public Phone(String name){
        this.name = name;
    }

    public void sayHi() {
        System.out.println(name);
    }
}

// 构造方法的练习

/* 需求:
* 创建一个长方形的类
* 设计 
* 成员变量 长 宽 周长 面积 
* 方法
* 计算周长和面积 自我介绍
* 要求: 
* 1.构造方法(有参 无参)
* 2.set/get
*/ 
public class Demo03 {
    public static void main(String[] args) {
        Oblong wj = new Oblong(10,5);
        wj.sayHi();
        System.out.println("面积是" + wj.getAcreage());
        System.out.println("周长是" + wj.getGirth());
    }
}
 class Oblong{
     private int height;
     private int width;
     // 添加两个成员变量
     private int girth; // 周长
     private int acreage; // 面积
     // 无参构造方法
     public Oblong(){

     }
     // 有参构造方法
     public Oblong(int height,int width) {
         this.height = height;
         this.width = width;
         // 可以通过计算,赋值成员变量
         this.girth = (height * 2) + (width * 2);
         this.acreage = width * height;
     }

     public void setHeight(int height) {
         this.height = height;
     }
     public int getHeight() {
         return height;
     }
     public void setWidth(int width) {
         this.width = width;
     }
     public int getWidth() {
         return width;
     }
     // 选择性提供set/get方法
     // 用户不能随意输入更改面积周长,所以只提供get的方法就行
     // 输出周长
     public int getGirth() {
         girth = (height * 2) + (width * 2);
         return girth;
     }
     // 输出面积
     public int getAcreage() {
         acreage = width * height;
         return acreage;
     }
     public void sayHi() {
         System.out.println("长是:" + height + "," + "宽是:" + width);
     }
 }

类之静态变量

1.静态变量的含义
静态变量: 共享的成员变量,被所有的对象共享
关键词: static(修饰成员变量)
// static修饰成员变量
// 该成员变量 会存储在方法区的静态区

举例:空调(一个房间的所有人共享)
静态变量的好处:节省了内存空间

2.调用静态变量
1.使用 对象名.静态变量名 来调用(不推荐使用,容易与成员变量混淆)
2.使用 类名.静态变量名 来调用(推荐使用,更好的区分 成员变量和静态变量)

// 创建 明星类
class Star{
    String name;
    // 定义 成员变量(转换成静态变量)
    static String country;

    public void sayHi(){
        System.out.println("姓名:" + name);
        System.out.println("国籍:" + country);
    }
}

// 生成 明星对象
public class Demo {
    public static void main(String[] args) {
        Star no1 = new Star();
        no1.name = "成龙";
        // 通过 对象名.静态变量名 调用(不推荐)
        // no1.country = "中国";
        Star.country = "中国";
        no1.sayHi();

        Star no1 = new Star();
        no1.name = "周星驰";
        // 不需要再次赋值
        // no2.country = "中国";
        no2.sayHi();
    }
}

• 描述 代码在内存中的表现
  
  • 1.加载 main函数所在的类的 .class文件
  • Demo.class 加载进入方法区
  • 2.创建 Star对象 ,先要加载Star.class
  • 3.在堆内存中 创建Star对象
    
    • 该内存中保存了 成员变量
    • 把系统分配的内存地址 返回给no1保存
  • 4.通过no1赋值成员变量
  • 5.通过类名 赋值 静态变量
  • 6.sayHi方法 入栈 打印 出栈
  • 7.main执行完毕
  • 8.程序结束

---

3. 成员变量与静态变量的区别:
  1.调用方式
        成员变量:对象调用
        静态变量:对象 和 类名(推荐)  都能调用
  2.内存中的表现
        成员变量:堆内存
        静态变量:方法区的静态区
  3.所属不同
        成员变量:属于对象
        静态变量:属于类的(不依赖对象的创建)
  4.生命周期
        成员变量:随着对象的创建而创建,随着对象的销毁而销毁
        静态变量:随着类的加载而创建,随着程序结束而销毁
  注意:类是 优先对象存在的

类之静态方法

1. 静态变量(类变量)
   静态方法(类方法)

2.静态方法(和成员方法一样,也是进栈执行)
  1️⃣什么时候 静态方法加载进内存?

  同静态变量一样,被加载到方法区的静态区
  静态方法:随着类的加载而加载

  2️⃣静态方法能否使用成员变量?  不能
    原因:静态方法被加载时,可能还没有对象产生,所以成员变量无法被调用
    注意:也不能使用 this关键字
    // 在本类中调用 本类的方法,可以省略this 或 类名

3.静态方法的调用:
 1️⃣对象调用(不推荐)
 2️⃣直接使用类名调用(推荐)

特殊
以上总结:静态方法 只能使用静态的变量或方法

// 举例
class Test{
        int number1 = 10;
        static int number2 = 20;

        //  成员方法中 可以使用成员变量,也可以使用静态变量
        public void fun1() {
            int number1 = 15;
            int number2 = 25;
            // 成员变量
            System.out.println(this.number1);
            // 静态变量
            System.out.println(Test.number2);
            // 在本类中调用 本类的方法,可以省略this 或 类名
            fun2();
        // 静态方法 只能使用静态的方法或者变量
        public static void fun2() {
            System.out.println(Test.number2);
        }
    }

main方法解析

 public 表示方法的使用权限  公开的
 static JVM可以直接使用类名 调用类方法(不用创建对象就可以调用)
 void   没有返回值
 main   不是关键字,但是名字不能换   
          JVM运行代码时  就是找叫 类中main这个静态方法
 String[]  args    可以接受用户的输入
                     整个main中所有的词  都不能换 只有args能换 

封装一个数组的工具类 制作文档

 当一个类中全是静态方法,这时可以 私有化构造方法
  (因为根本用不到对象)
  一般工具类都会这样设计

  Constructor 构造

  制作文档(编译器中)
  javadoc -d(生成文档路径) -version -author 文件名.java

/**
 * 数组工具类
 * 获取数组最大值
 * 打印数组
 * 数组反转
 * 选择排序
 * @author lanou
 * @version 1.0.0
 *
 */
public class ArrayTool {
    /**
     * 构造方法私有化
     */
    private ArrayTool() {

    }

    /**
     * 获取数组中的最大值
     * @param array   传入的参数
     * @return    返回数组最大值
     */
    public static int maxReturn(int[] array) {
        int max = array[0];
        for (int i = 0; i < array.length; i++) {
            if(array[i] > max) {
                max = array[i];
            }
        }
        return max;
    }
    /**
     * 打印数组
     * @param array 传入的参数
     */
    public static void arrayprint(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
    /**
     * 数组反转
     * @param array 传入的参数
     */
    public static void arrayreverse(int[] array) {
        int num = array.length/2;
        for (int i = 0; i < num; i++) {
            int temp = array[array.length-1-i];
            array[array.length-1-i] = array[i];
            array[i] = temp;
        }
    }
    /**
     * 选择排序
     * @param array 传入的参数
     */
    public static void chioceSort(int[] array) {
        for (int i = 0; i < array.length-1; i++) {
            for (int j = i + 1; j < array.length; j++) {
                if(array[i] > array[j]) {
                    int temp = array[j];
                    array[j] = array[i];
                    array[i] = temp;
                }
            }
        }
    }
}

## 面向对象的思维 ##

/*
 * 面向对象
 * 设计完成 石头剪刀布
 * 人和电脑比较 打印比较结果
 * 
 * 分类:
 * 人类: 
 *      人出拳的方法  
 * 电脑类:
 *      电脑出拳的方法   
 * 比较类:
 *          参数:人出的拳  电脑出的拳
 * 游戏类:
 *          游戏开始的方法
 * 测试类  :
 *      调用游戏开始方法
 */


// 人类
public class Person {
    // 出拳方法
    // 把出的拳 转化成数字 方便一会比较
    // 石头1  剪刀2  布3
    public static int fist() {
        System.out.println("请输入石头剪刀布:");
        Scanner wangjun = new Scanner(System.in);
        String str = wangjun.nextLine();
        // 定义变量,保存结果
        int num = 0;
        switch (str) {
        case "石头":
            num = 1;
            System.out.println("人出的是: 石头");
            break;
        case "剪刀":
            num = 2;
            System.out.println("人出的是: 剪刀");
            break;
        case "布":
            num = 3;
            System.out.println("人出的是: 布");
            break;
        default:
            break;
        }
        return num;
    }

// 电脑类

public class Computer {
    public static int fist() {
        int num = (int)(Math.random()*3 + 1);
        switch (num) {
        case 1:
            System.out.println("电脑出的是 石头");
            break;
        case 2:
            System.out.println("电脑出的是 剪刀");
            break;
        case 3:
            System.out.println("电脑出的是 布");
            break;
        default:
            break;
        }   
        return num;
    }
}

//  比较类

/*
 * 人        电脑          结果
 * 1            1           0    平
 * 1            2          -1    人赢
 * 1            3          -2    电脑赢
 * 2            1           1    电脑赢
 * 2            2           0    平
 * 2            3          -1    人赢
 * 3            1           2    人赢
 * 3            2           1    电脑赢
 * 3            3           0    平
 * 
 * 0    平
 * -1   2   人赢
 * -2   1   电脑赢
 */
public class Compare{
    public static int compareFist(int pNum,int cNum) {
        int num = pNum - cNum;
        int number = 0;
        if(num == 0) {
            System.out.println("战平");
        }else if(num == -1 || num == 2) {
            System.out.println("人赢");
            number++;
        }else {
            System.out.println("电脑赢");
            number--;
        }
        return number;
    }
}

// 游戏类

public class Game {
    public static void gameStart() {
        int pNum = Person.fist();
        int cNum = Computer.fist();
//      Compare.compareFist(pNum, cNum);
        int num1 = Compare.compareFist(pNum, cNum);
        int pNum1 = Person.fist();
        int cNum1 = Computer.fist();
//      Compare.compareFist(pNum1, cNum1);
        int num2 = Compare.compareFist(pNum1, cNum1);
        int pNum2 = Person.fist();
        int cNum2 = Computer.fist();
//      Compare.compareFist(pNum2, cNum2);
        int num3 = Compare.compareFist(pNum2, cNum2);
        int num = num1 + num2 + num3;
        if(num < 0) {
            System.out.println("电脑赢了");
        }else if(num == 0) {
            System.out.println("打平");
        }else {
            System.out.println("人赢了");
        }
    }
}

// 测试类
public class GameTest {
    public static void main(String[] args) {
        Game.gameStart();
    }
}