让我们进入面向对象的世界(二)

让我们进入面向对象的世界(二)

---

提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

相信大家已经看到了我的第一篇文章，相信对面向对象有了一定初步的理解。
这里我为了带大家提前能够进入状态，我为大家准备了个小练习。
猜数字游戏大家都玩过吧。

这里我说明一下规则。
大概就是用电脑说出一个数字，玩家去猜，猜到了，有奖。
这里我们涉及到game 类 和player 对象

game产生介余0~9之间的随机数，而3个player对象会猜这个数字。
这里我们涉及的类是

Guessname.class
Player.class
GameLuancher.class

程序的逻辑是：
1.GameLuancher 这个类有main方法，是应用程序的入口。
2.main()中会创建Guess对象，并且调用startGame()方法。
3.startGame()方法是游戏的起点，
它会创建三个player，
然后挑选出要猜测的随机对象，它会要求player猜测并检查结果，过程会被列出来

类的设计如下：

看来上面的设计，你就会发现，我们在想一个问题的时候，是在想这里面有哪些对象，并且针对对象，设计相应的行为，我们思路就清晰了。
类的代码如下：

package Test5;

public class GuessGame {
    //3个实例变量，分别表示三个player对象
    Player p1;
    Player p2;
    Player p3;
    public  void startGame(){
        //创建出player对象
        p1=new Player();
        p2=new Player();
        p3=new Player();
        //用三个变量保存是否猜中
        int guessp1=0;
        int guessp2=0;
        int guessp3=0;

        //声明三个变量来保存猜测的数字
        boolean p1isRight=false;
        boolean p2isRight=false;
        boolean p3isRight=false;
        int targetNumber=(int)(Math.random()*10);//产生谜底数字
        System.out.println("我认为这个数字应该是 0 到 10");
        while(true){
            System.out.println("要猜的数字是"+targetNumber);
            //用户开始猜数字
            p1.guess();
            p2.guess();
            p3.guess();
            //取出每个玩家所猜测的数字并将它列出
            guessp1=p1.number;
            System.out.println("玩家一 猜的数字是"+guessp1);
            guessp2=p2.number;
            System.out.println("玩家二 猜的数字是"+guessp2);
            guessp3=p3.number;
            System.out.println("玩家三 猜的数字是"+guessp3);
            //检测是否猜中
            if (guessp1 == targetNumber) {
                p1isRight =true;
            }
            if (guessp2 == targetNumber) {
                p2isRight =true;
            }
            if (guessp3 == targetNumber) {
                p3isRight =true;
            }
            if (p1isRight || p2isRight || p3isRight ) {
                System.out.println("我们赢了");
                System.out.println("第一个玩家是否胜利？"+p1isRight);
                System.out.println("第二个玩家是否胜利？"+p2isRight);
                System.out.println("第三个玩家是否胜利？"+p3isRight);
                System.out.println("游戏结束");
                break;

            }else {
                System.out.println("请继续猜下去");
            }
        }
    }


}

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
62
63

package Test5;

public class Player {
    int number=0;//要被猜的数字
    public  void guess(){
        number= (int)(Math.random() *10);
        System.out.println("这是我猜的数字"+number);
    }

}

1
2
3
4
5
6
7
8
9
10
11

public class GameLauncher {
    public static void main(String[] args) {
        GuessGame guessGame=new GuessGame();
        guessGame.startGame();


    }
}
1
2
3
4
5
6
7
8

通过这里大家可以看到，我们运行程序的结果，很简单明了，是不是对面向对象的思想更加好奇了呢？
哈哈，别急，别急，我们下面还有个新概念，既然我们创建了对象，知道了怎么初始化对象，但我们具体怎么操作对象的呢？

二.对象的操作

事实上，我们通过对象的引用来操作对象，具体的话，我们来看下面和这个例子：

Dog dog =new Dog();
dog.name="旺财"
dog.wang();
/*
打印的结果嘛。当然是 旺财在汪汪叫！
*
/

1
2
3
4
5
6
7
8

这里事实上，我们是用圆点运算符加引用值，进行对象操作的。

这里就不得不又扯上创建一个对象是怎么样一个流程，大家有必要了解一下。
1.声明一个引用变量
2.创建对象
3.连接对象和引用

看文字或许有些生涩难懂，让我们看图说话

大致清楚了，对象的创建流程以后，我们来看一段代码，你们猜猜会输出什么。

   		Book book1=new Book();
        Book book2=new Book();
        System.out.println(b1);
        System.out.println(b2);
1
2
3
4

你可以看出，我用打印语句去打印出来的地址是不相同的，为什么呢？
从图片来看，这俩个引用，其实是指向了不同的对象，所以地址不同。

我们在进一步往下看。
假如，这个时候，我们脑洞大开
声明新的Book引用变量
但不创建新的Book对象而将变量c的值赋值给变量d。
这代表“将c的字节组合拷贝给变量d。

Book book1=new Book();
Book book2=new Book();
Book book3=book1;
1
2
3

这时候的图又是这样的：

接下来我们做一个操作，就是更改对象的绑定，来访问对象，看看会发生什么

  		Book b1=new Book();
        Book b2=new Book();
        b1=b2;
        b1.name="七龙珠";
        System.out.println(b1.name);
        System.out.println(b2.name);
        System.out.println(b1);
        System.out.println(b2);
1
2
3
4
5
6
7
8

运行结果如下:

如果还是没有明白为什么会发生这样的事情，我们再来画个图理解理解。

当然我们对对象也可以让它的引用不指向任何东西。
就按照以下操作即可：

  Book book1=new Book();
  Book book2=new Book();
  b2=null;
1
2
3

当我们对象引用为null时，它就不指向任何的对象哦。

到了这里我相信你对对象的概念又更加深刻了。

三.让我们离对象村更进一步，进入面向对象封装的特性

有句话说得好不封装就会难堪，怎么个难堪法呢，就好比你的袜子破了个洞，结果全世界都知道了。是不是尴尬死。
换到我们程序语言来说，就好比有如下的程序

public class Book {
    String name;
    String price;

    public Book(){

    }
    public Book(String name, String price) {
        this.name = name;
        this.price = price;
    }
}

public class TestBook {
    public static void main(String[] args) {
        Book b1=new Book();
        Book b2=new Book();
         b2.name="七龙珠";
        System.out.println(b2.name);       
	


    }
}


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

以上的程序的话，我们就可以随意去修改图书的值，还可以随意去访问。可能这还是不够严重，你觉得，打个比方，你的私人空间，谁都可以来留下印记，你说可怕不可怕。

因此我们面向对象引入了封装的概念。
大家可以了解一下封装的基本原则。
1.将你的实例变量标记成私有的。
2.并且提供私有的getter和setter方法来控制存取动作。

具体怎么封装，我们来看一个例子，你就明白了。

package Test8;

public class Dog {
    private int Size;

    public int getSize() {
        return Size;
    }

    public void setSize(int size) {
        Size = size;
    }
    public void  bark(){
        if (Size > 60) {
            System.out.println("哦哦哦");
        }
        else {
            System.out.println("滴滴滴");
        }
    }
}

class GoodDogTestDrive{
    public static void main(String[] args) {
        Dog one=new Dog();
        one.setSize(70);
        Dog two=new Dog();
        two.setSize(10);
        one.bark();
        two.bark();
    }

}
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

运行结果

看懂了封装，我们来进入一个小插曲，就是我们一直说的进入下一个困惑点。

四 实例变量和局部变量之间的区别

我们用俩句简单话理解。
实例变量是声明在类中的。
局部变量是声明在方法中的。

记住这俩句话，你就掌握了Java中局部变量和实例变量的区别。

public class Test {

    class Dog {
        //实例变量
        String name;
        String ID;
    }
    public void Doing(){
        int a;//这是局部变量
        int b;
    }

    public static void main(String[] args) {



    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

这里说实话，还有一条可注意的，局部变量在使用之前，必须初始化，你强行使用的话，就会报错。

大家好！今天的面向对象之旅，就结束了，接连的几天我们都会在面向对象的世界里遨游。