《Head First Java》| 2-3 拜访对象村+认识变量

拜访对象村

椅子大战

需求：在图形接口画出四方形、圆形、三角形与阿米巴虫形状，点用户点击图形时，图形需要顺时针旋转360°并依据形状的不同播放不同的AIF音效文件。
面向对象方法：

类与对象的关系

对象带有实例变量和方法，但它们都是类设计中的一部分。
类是创建对象的蓝图（可以把类想象成通讯簿，每张卡片都有相同的空白字段（实例变量），填上不同的数据就创建了新的对象。卡片上的方法是你会对卡片做的事情。所以每张卡片都能执行相同的动作，却得到相互独立的结果。）

创建并测试你的第一个对象

运用对象需要两个类，一个用于定义对象，一个用于测试对象。
测试用的类命名为：“受测类名称”+TestDrive

class Dog {
    // 实例变量
    int size;
    String breed;
    String name;

    // 方法
    void bark() {
        System.out.println("汪 汪");
    }
}

class DogTestDrive {
    public static void main (String[] args){
        // Dog测试码
        Dog d = new Dog();
        d.size = 40;
        d.bark();
    }
}

汪 汪

创建与测试Movie对象（同上，只是在测试类中多定义几个对象）

class Movie {
    // 实例变量
    String title;
    String genre;
    int rating;
    // 方法
    void playIt(){
        System.out.println("Playing the movie");
    }
}

class MovieTestDrive {
    public static void main (String[] args) {
        Movie one = new Movie();
        one.title = "断背山";
        one.genre = "love";
        one.rating = 8;

        Movie two = new Movie();
        two.title = "色戒";
        two.genre = "spy";
        two.rating = 7;
        two.playIt();

        Movie three = new Movie();
        three.title = "我和我的祖国";
        three.genre = "country";
        three.rating = 7;
    }
}

Playing the movie

对象又叫做实例，可以通过圆点计算符来设定实例变量的数据。

快离开main！

main的两种用途：

• 测试真正的类
• 启动你的Java应用程序

猜数字游戏：

public class GuessGame {
    // 实例变量
    Player p1;
    Player p2;
    Player p3;
    // 方法
    public void startGame(){
        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); // 产生0-9之间的随机数
        System.out.println("I am thing of a number between 0 and 9...");

        while(true){
            System.out.println("Number to guess is " + targetNumber);

            p1.guess();
            p2.guess();
            p3.guess();

            guessp1 = p1.number;  // 取出每个player猜测的数字并列出
            System.out.println("Player one guessed" + guessp1);
            guessp2 = p2.number;
            System.out.println("Player two guessed" + guessp2);
            guessp3 = p3.number;
            System.out.println("Player three guessed" + guessp3);

            // 检查是否猜中，若猜中则去设置“是否猜中”的变量
            if(guessp1 == targetNumber){
                p1isRight = true;
            }
            if(guessp2 == targetNumber){
                p2isRight = true;
            }
            if(guessp3 == targetNumber){
                p3isRight = true;
            }

            // 结果
            if (p1isRight || p2isRight || p3isRight ){
                System.out.println("We have a winner!");
                System.out.println("Player one got it right? " + p1isRight);
                System.out.println("Player two got it right? " + p2isRight);
                System.out.println("Player three got it right? " + p3isRight);
                System.out.println("Game is over.");
                break;
            }
            else{
                // 都没猜中，所以要继续下去
                System.out.println("Players will have to try again.");
            }


        }
    }

}

class Player {
    int number = 0;       // 要被猜的数字

    public void guess() {
        number = (int)(Math.random() * 10);
        System.out.println("I am guessing" + number);
    }
}

class GameLaincher {
    public static void main (String[] args){
        GuessGame game = new GuessGame();
        game.startGame();
    }
}

I am thing of a number between 0 and 9…
Number to guess is 3
I am guessing0
I am guessing0
I am guessing7
Player one guessed0
Player two guessed0
Player three guessed7
Players will have to try again.
Number to guess is 3
I am guessing1
I am guessing2
I am guessing6
Player one guessed1
Player two guessed2
Player three guessed6
Players will have to try again.
Number to guess is 3
I am guessing3
I am guessing4
I am guessing9
Player one guessed3
Player two guessed4
Player three guessed9
We have a winner!
Player one got it right? true
Player two got it right? false
Player three got it right? false
Game is over.

一些问题：

• Java如何定义全局变量？

在Java中不存在全局变量这回事，可以用public、static和final，基本上可以让变量变得类似“global”

• 面向对象有哪些特点？

1. 面向对象程序扩展时不需要改动之前已经测试好的代码。
2. 所有的Java程序都定义在类中。
3. 类如何蓝图描述该类型的对象如何创建。
4. 对象本身的数据称为实例变量，它代表对象的状态；对象可执行的动作称为方法，它代表行为。
5. 创建类时，可能同时会需要创建独立、测试用的类。
6. 类可以继承自较为抽象的父类。

练习

排排看
要求输出：

bang bang ba-bang
ding ding da-ding

public class DrumKit {
    boolean topHat = true;
    boolean snare = true;

    void playSnare() {
        System.out.println("bang bang ba-bang");
    }
    void playTopHat() {
        System.out.println("ding ding da-ding");
    }
}

class DrumKitTestDrive {
    public static void main (String[] args) {
        DrumKit d = new DrumKit();
        if(d.snare = true) {
            d.playSnare();
        }
        d.playTopHat();
        d.snare = false;

    }
}

泳池迷宫：
要求输出

helloooo…
helloooo…
helloooo…
helloooo…
10

class Echo {
    int count = 0;

    void hello(){
        System.out.println("helloooo...");
    }
}

class EchoTestDrive {
    public static void main (String[] args) {
        Echo e1 = new Echo();
        Echo e2 = new Echo();
        int x=0;
        while(x<4) {
            e1.hello();
            e1.count = e1.count +1;
            if (x==3) {
                e2.count = e2.count+1;
            }
            if (x>0) {
                e2.count =e2.count + e1.count;
            }
            x = x+1;
        }
        System.out.println(e2.count);
    }
}

认识变量

Java中的变量必须要有类型+名称。
变量有两种： 基本数据类型（如整数、浮点型、布尔型等）或 引用数据类型。

Java八大数据类型

参考博客：Java八种基本数据类型

给变量赋值的方式：

• 变量可以直接指定类型，不赋值 int x；
• 在等号后面直接打出 int x=8;
• 指派其他变量的值 x=y;
• 上述两种方式的组合 intx =y+8;

变量命名的规则：

• 不能用数字开头
• 避开Java关键字 boolean, char, byte, short, int, long, float, double…

数组变量

创建大小为7的数组变量并赋值；

int [] nums = new int[7];
nums[0] = 6;
nums[1] = 7;
nums[2] = 19;
...

注意：

• 无论数组中的元素是什么数据类型，数组都是对象。
• 一旦数组被声明出来，数组就只能装入所声明类型的元素。

定义myDog数组练习：

public class myDog {
    String name;
    public static void main(String[] args) {
        // 创建Dog对象
        myDog dog1 = new myDog();
        dog1.bark();
        dog1.name = "Bart";

        // 创建Dog数组
        myDog[] myDogs = new myDog[3];

        // 装进狗对象
        myDogs[0] = new myDog();
        myDogs[1] = new myDog();
        myDogs[2] = dog1;

        // 通过数组引用存取DOg
        myDogs[0].name = "Fred";
        myDogs[1].name = "Marg";

        // myDog[2]的名字是？
        System.out.print("last dog's name is");
        System.out.println(myDogs[2].name);

        // 逐个dog执行bark()
        int x=0;
        while(x < myDogs.length) {
            myDogs[x].bark();
            x = x+1;
        }
    }
    public void bark() {
        System.out.println(name+" says Ruff!");
    }
    public void eat() {}
    public void chaseCat() {}
}

null says Ruff!
last dog’s name isBart
Fred says Ruff!
Marg says Ruff!
Bart says Ruff!

练习

排排看：

public class TestArrays {
    public static void main (String[] args) {
        // 创建数组
        int [] index = new int[4];
        String [] islands = new String[4];

        // 传入数组变量
        index[0] = 1;
        index[1] = 3;
        index[2] = 0;
        index[3] = 2;
        islands[0] = "Bermuda";
        islands[1] = "Fiji";
        islands[2] = "Azores";
        islands[3] = "Cozume1";

        // 打印
        int y=0;
        int ref;
        while(y<4) {
            ref = index[y];
            System.out.print("island = ");
            System.out.println(islands[ref]);
            y = y+1;
        }
    }
}

island = Fiji
island = Cozume1
island = Bermuda
island = Azores

泳池迷宫：

public class Triangle {
    double area;
    int height;
    int length;
    public static void main(String[] args) {
        int x = 0;
        Triangle [] ta = new Triangle[4];
        while(x<4){
            ta[x] = new Triangle();
            ta[x].height = (x+1)*2;
            ta[x].length = x+4;
            ta[x].setArea();
            System.out.print("traingle "+x+",area");
            System.out.println("="+ta[x].area);
            x = x+1;
        }
        int y=x;
        x = 27;
        Triangle t5 = ta[2];
        ta[2].area = 343;
        System.out.print("y=" + y);
        System.out.println(", t5 area=" + t5.area);
    }
    void setArea(){
        area = (height*length) / 2 ;
    }
}

输出：

traingle 0,area=4.0
traingle 1,area=10.0
traingle 2,area=18.0
traingle 3,area=28.0
y=4, t5 area=343.0