面向对象--封装

三大特性之封装

private 关键字

private：私有的，带有private修饰的方法和变量不可以直接被调用，只能通过公有的方法进行调用和赋值
public：公有的，可以直接被调用

公有变量和私有变量使用方式

例子：

定义一个名字为Person的类

/**
 * @Classname : Person
 * @Description : TODO 人类
 * @Author : [email protected]
 */
public class Person {
    //定义一个公有成员变量
    public String name; //姓名
    //定义一个私有成员变量
    private int age; // 年龄
    /**
     * 返回私有成员变量age的值的方法
     * @return
     */
    public int getAge() {
        return age;
    }
    /**
     * 对私有成员变量 age进行赋值的方法
     * 设置年龄的范围 0-130之间的年龄
     * @param age 年龄
     */
    public void setAge(int age) {
        if(age < 0 || age > 130){
            System.out.println("非法年龄，默认年龄 18 岁");
            this.age = 18;
            return;
        }
        this.age = age;
    }
}

调用上面的类

import java.util.Scanner;
/**
 * @Classname : test
 * @Description : TODO 测试类
 * @Author : [email protected]
 */
public class test {
    public static void main(String[] args) {
        //实例化Person类
        Person person = new Person();
        //公有成员变量调用
        person.name = "小肆"; //调用公有变量name,直接赋值为"小肆"
        System.out.println("姓名：" + person.name); // 小肆
        System.out.println("=======================");
        //调用私有成员变量age的方式
        //1.通过公有方法setAge进行赋值
        int age;
        System.out.print("请输入年龄:");
        age = new Scanner(System.in).nextInt();//获取输入的年龄
        person.setAge(age);
         //2.调用公有方法getAge，获取私有变量age的值
        System.out.println("年龄：" + person.getAge());
    }
}

直接调用私有成员变量age成员会报错

私有成员变量掉只能通过公有方法进行调用和赋值

通过private封装的变量，可以更加安全的使用，如果age是公有变量可以随意赋值这样会更乱，
运行结果：

1. 输入非法年龄时触发默认年龄的设置
   
2. 正常年龄输入直接输出
   

调用私有方法的方式

和调用私有成员变量的方式一样，也是需要一个公有方法进行调用

例子：

/**
 * @Classname : Person
 * @Description : TODO 人类
 * @Author : [email protected]
 */
public class Person {
       // 定义一个私有的成员方法
      private void pri(){
          System.out.println("pri是私有方法，已经被调用");
      }
      // 定义一个公有的成员方法，该方法作用是调用上面的pri方法
     public void getPri(){
          this.pri();
     }
}

掉上面的类

/**
 * @Classname : test
 * @Description : TODO 测试类
 * @Author : [email protected]
 */
public class test {
    public static void main(String[] args) {
        //实例化Person类
        Person person = new Person();
        //调用Person类公有方法getPri
        person.getPri();
    }
}

直接调用私有方法程序也会报错，调用私有方法也是只能通过公有方法

运行结果：

构造方法

构造方法的介绍

1. 与类同名
2. 无返回值
3. 如果不手动创建构造方法，则系统默认生成一个无参构造方法
4. 构造方法不需要手动调用，在类创建对象时被自动调用
5. 如果手动创建了构造方法，系统则不再生成无参的构造方法
6. 构造方法支持重载

构造方法的作用

构造方法可以对类里面的成员变量进行初始化

例子：

定义一个名字为Person的类,里面有几个构造方法

/**
 * @Classname : Person
 * @Description : TODO 人类
 * @Author : [email protected]
 */
public class Person {
      //定义两个成员方法
      public String name;
      public int age;
      //定义一个无参的构造方法
      Person(){
          System.out.println("我是无参数的构造方法");
      }
      
      //定义3个带参数的构造方法
    /**
     * 给类中成员变量name进行初始化的构造方法
     * @param name 姓名
     */
    public Person(String name) {
        this.name = name;
    }

    /**
     * 给类中成员变量age进行初始化的构造方法
     * @param age 年龄
     */
    public Person(int age) {
        this.age = age;
    }

    /**
     *  类中 name , age 进行初始化的构造方法
     * @param name
     * @param age
     */
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
     
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

调用上面类

/**
 * @Classname : test
 * @Description : TODO 测试类
 * @Author : [email protected]
 */
public class test {
    public static void main(String[] args) {
            //实力例化对象Person
        Person person = new Person();
        Person person1 = new Person("小肆",17);
        System.out.println(person1);//对象字符串化输出
    }
}

1. 当自己定义了带参数的构造方法，一定要自己写一个无参数的构造方法
2. toString：简单理解为可以把一个对象字符串化，通过println方法输出一个对象时，toString会被自动调用

运行结果：

案例-猜拳游戏（和电脑猜拳）

玩家的定义

玩家类定义需要定义两个属性，一个是玩家姓名，一个是出拳方式,以及一些需要用到构造方法

/**
 * @Classname : Player
 * @Description : TODO 玩家类
 * @Author : [email protected]
 */
public class Player {
    //定义两个成员属性
    private String name; //姓名
    private int res; // 出拳结果

    //定义构造方法
    public Player() {
    }

    public Player(String name) {
        this.name = name;
    }

    public Player(int res) {
        this.res = res;
    }

    public Player(String name, int res) {
        this.name = name;
        //设置出拳结果,res 取值1-3
        if(res <= 0 || res >= 4){
            System.out.println("出拳无效~");
            System.exit(0);
        }
        this.res = res;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getRes() {
        return res;
    }

    public void setRes(int res) {
        this.res = res;
    }
}

裁判类

获取两个玩家的信息进行判断

/**
 * @Classname : trial
 * @Description : TODO 裁判类
 * @Author : [email protected]
 */
public class trial {
    //定义两个Player类的对象
    private Player player01;
    private Player player02;

    public trial() {
    }

    public trial(Player player01, Player player02) {
        this.player01 = player01;
        this.player02 = player02;
    }
    /**
     * 裁判判断结果的方法
     * 1 - 石头
     * 2 - 剪刀
     * 3 - 布
     */
    public void res(){
        //定义一个字符串数组，存储出拳方式
        String [] r = {"石头","剪刀","布"};
        //输出两个人的姓名和出拳方式
        System.out.printf("%s - %s VS %s - %s\n",player01.getName(),r[player01.getRes()-1],
                                                 player02.getName(),r[player02.getRes()-1]);
        //判断两个选手出拳
        if(player01.getRes() == player02.getRes()){
            System.out.println("平局");
        }else if(player01.getRes() == 1 && player02.getRes() == 2 ||
                 player01.getRes() == 2 && player02.getRes() == 3 ||
                 player01.getRes() == 3 && player02.getRes() == 1){
            System.out.println(player01.getName() + "胜利");
        }else{
            System.out.println(player02.getName() + "胜利");
        }
    }
}

测试游戏

调用上面的玩家类和裁判类

import java.util.Random;
import java.util.Scanner;

/**
 * @Classname : game
 * @Description : TODO 游戏类
 * @Author : [email protected]
 */
public class game {
    public static void main(String[] args) {
        //和计算机猜拳,获取一个随机数1-3
        int res01 = new Random().nextInt(3)+1;//
        Player player = new Player("电脑",res01);
        System.out.println("请输入你的出拳方式（1-石头，2-剪刀，3-布）");
        int res02 = new Scanner(System.in).nextInt();
        Player player1 = new Player("小肆",res02);
        //调用裁判
        trial trial = new trial(player,player1);
        trial.res();

    }
}

运行结果：