Java语言程序设计 对象和类

为对象定义类：面向对象程序设计（OOP)就是使用对象进行程序设计。对象（object）代表现实世界中可以明确标识的一个实体。每个对象都有自己独特的标识、状态和行为。 

•  一个对象的狀态（state，也称为特征（property）或属性（attribute）)是由具有当前值的数据域来表示的。例如：圆对象具有一个数据域 radius, 它是标识圆的属性。一个矩形对象具有数据域 width 和 height,它们都是描述矩形的属性。
•  —个对象的行为（behavior, 也称为动作（action))是由方法定义的。调用对象的一个方法就是要求对象完成一个动作 。例如：可以为圆对象定义一个名为getArea() 和 getPerimeter() 的方法。圆对象可以调用getArea() 返回圆的面积，调用getPerimeter() 返回它的周长。

       使用一个通用类来定义同一类型的对象。类是一个模板、蓝本或者说是合约，用来定义对象的数据域是什么以及方法是做什么的。一个对象是类的一个实例。可以从一个类中创建多个实例。创建实例的过程称为实例化（instantiation)。对象（object) 和实例（instance)经常是可以互换的。类和对象之间的关系类似于苹果派配方和苹果派之间的关系。可以用一种配方做出任意多的苹果派来。

局部变量和成员变量的区别：

区别一：定义的位置不同，成员变量定义在类中，局部变量定义在方法中或者语句里面； 

区别二：在内存中的位置不同，成员变量存储在堆内存的对象中，局部变量存储在栈内存的方法中；

区别三：声明周期不同，成员变量随着对象的出现而出现在堆中，随着对象的消失而从堆中消失，局部变量随着方法的运行而出现在栈中，随着方法的弹栈而消失；

区别四：初始化不同，成员变量因为在堆内存中，所有默认的初始化值，局部变量没有默认的初始化值，必须手动的给其赋值才可以使用。

构造函数：

      从字面上理解即为构建创造时用的函数，即就是对象创建时要执行的函数。既然是对象创建时要执行的函数，那么只要在new对象时，知道其执行的构造函数是什么，就可以在执行这个函数的时候给对象进行属性赋值 。

构造方法是一种特殊的方法。它们有以下三个特殊性：

• 构造方法必须具备和所在类相同的名字。
• 构造方法没有返回值类型，甚至连 void也没有。
• 构造方法是在创建一个对象使用new 操作符时调用的。构造方法的作用是初始化对象。

构造函数和一般函数的区别：构造函数在对象创建时就执行了，而且只执行一次。 一般函数是在对象创建后，需要使用时才被对象调用，并可以被多次调用。 

this:关键字 this 是指向调用对象本身的引用名。可以用 this 关键字引用对象的实例成员。

this到底代表什么呢？this代表的是对象，具体代表哪个对象呢？哪个对象调用了this所在 的函数，this就代表哪个对象。 调用其他构造函数的语句必须定义在构造函数的第一行，原因是初始化动作要最先执行 。

通过引用变量访问对象 ：对象的数据和方法可以运用点操作符（.）通过对象的引用变量进行访问。

对象是通过对象引用变量（reference variable)来访问的，该变量包含对对象的引用，使用如下语法格式声明这样的变量：
ClassName objectRefVar;

本质上来说，一个类是一个程序员定义的类型。类是一种引用类型（referencetype),这意味着该类类型的变量都可以引用该类的一个实例。

在面向对象编程中，对象成员可以引用该对象的数据域和方法。在创建一个对象之后， 它的数据和方法可以使用点操作符（ .）来访问和调用，该操作符也称为对象成员访问操作符 (object member access operator)：

• objectRefVar.dataField 引用对象的数据域。
• objectRefVar.method(arguments)调用对象的方法。 

引用数据域和null值：

数据域也可能是引用型的。例如：下面的 Student 类包含一个 String类型的 name 数据域，String 是一个预定义的 Java 类。

如果一个引用类型的数据域没有引用任何对象，那么这个数据域就有一个特殊的 Java 值 null。null 同 true 和 false— 样都是一个直接量。true 和 false 是 boolean 类型直接量， 而null 是引用类型直接量。 

引用类型数据域的默认值是 null， 数值类型数据域的默认值是 0, boolean 类型数据域 的默认值是 false, 而 char类型数据域的默认值是 '\u0000'。但是，Java 没有给方法中的局部变置赋默认值。NullPointerException 是一种常见的运行时错误，当调用值为 null 的引用变量上的方法时会发生此类异常。

静态变量、常量和方法 ：

静态变量被类中的所有对象所共享。静态方法不能访问类中的实例成员。静态变量将变量值存储在一个公共的内存地址。因为它是公共的地址，所以如果某一个对象修改了静态变量的值，那么同一个类的所有对象都会受到影响。Java 支持静态方法和静态变量，无须创建类的实例就可以调用静态方法（static method)。 类中的常量是被该类的所有对象所共享的。因此，常量应该声明为 final static, 例如， Math 类中的常量 PI 是如下定义的：

final static double PI = 3.1415926535S979323846；

习题9.8： (风扇类 Fan)设计一个名为Fan的类来表示一个风扇。

class Class38{
    public static void main(String[] args){
        Fan debug1 = new Fan();    //为Fan类创建对象debug1
        debug1.setSpeed(3);    //调用修改器，修改里面的数据
        debug1.setOn(true);
        debug1.setRadius(10);
        debug1.setColor("yellow");
        System.out.println(debug1.toString());
        Fan debug2 = new Fan();    //创建第二个对象
        debug1.setSpeed(2);
        debug1.setOn(false);
        debug1.setRadius(5);
        debug1.setColor("blue");
        System.out.println(debug2.toString());
    }
}
class Fan{
    private final int SLOW = 1;
    private final int MEDIUM = 2;
    private final int FAST = 3;
    private int speed;
    private boolean on;
    private double radius;
    private String color;
    Fan(){
        this.speed = SLOW;
        this.on = false;
        this.radius = 5;
        this.color = "blue";
    }
    public String toString(){
        if(getOn()==false){
            return "Fan is off,color is "+getColor()+",radius is "+getRadius();   
        }else{
            return "Fan is on,color is "+getColor()+",radius is "+getRadius()+",speed is "
            +getSpeed();
        }
    }
    public void setSpeed(int speed) {
        this.speed = speed;
    }
    public int getSpeed() {
        return speed;
    }
    public void setOn(boolean on) {
        this.on = on;
    }
    public boolean getOn(){
        return on;
    }
    public void setRadius(double radius) {
        this.radius = radius;
    }
    public double getRadius() {
        return radius;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public String getColor() {
        return color;
    }
}

本题思路：将Fan这个类里面的数据都修改成private型，这样可以保证数据的安全性，接下来为这些数据添加修改器和访问器，以便我们里面能够简便的使用和修改它。

习题9.10： (代数：二次方程式）为二次方程式a*x^2+b*x+c=0，设计一个名为 QuadraticEquation的类。

class Class39{
    public static void main(String[] args){
        QuadraticEquation debug = new QuadraticEquation(3,2,0);
        //在主函数里面进行零，正和负数的判断
        if(debug.getDiscriminant()>0){
            System.out.println("root1 is "+debug.getRoot1()+",root2 is "+debug.getRoot2());
        }else if(debug.getDiscriminant()==0){
            System.out.println("only root1 is "+debug.getRoot1());
        }else{
            System.out.println("The Equation has no root");
        }
    }
}
class QuadraticEquation{
    //将数据私有化
    private double a;
    private double b;
    private double c;
    //构造函数进行初始化
    QuadraticEquation(double a,double b,double c){
        this.a = a;
        this.b = b;
        this.c = c;
    }
    //计算delt
    public double getDiscriminant(){
        double delt = Math.pow(getB(),2)-4*getA()*getC();
        return delt;
    }
    //如果delt小于零返回零
    public double getRoot1(){
        if(getDiscriminant()<0){
            return 0;
        }else{
            return (-getB()+getDiscriminant())/(2*getA());
        }
    }
    public double getRoot2(){
        if(getDiscriminant()<0){
            return 0;
        }else{
            return (-getB()-getDiscriminant())/(2*getA());
        }
    }
    public double getA() {
        return a;
    }
    public double getB() {
        return b;
    }
    public double getC() {
        return c;
    }
}

本题思路：和之前一样，将数据私有化，设置访问器，然后在类里面编写关于求解的函数并且去判断它的delt的数值，在主函数里面创建对象，利用if-else语句进行判断，然后用对象来调用类里面所写的函数。

习题：（游戏:猜字游戏）编写一个猜字游戏，随机产生一个单词，提示用户输入一个字母，当用户猜测正确后，正确的字母显示出，错误的话提示重新输入。

import java.util.*;
class Class34mine{
    public static void main(String[] args){
        //确定需要猜测的单词
        String[] words={
            "apple","englih","congratulations",
            "goodnight","welcome","mydog"
        };
        //创建对象，将String型的words传入进行初始化
        WordGame debug = new WordGame(words);
        //调用方法
        debug.startGame();
    }
}
class WordGame{
    private String[] words;
    private String word;
    private boolean[] states;
    private int misscount = 0;
    private Random random;
    public WordGame(String[] words){
        this.words = words;
        this.random = new Random();
    }
    //创建开始游戏比赛的函数
    public void startGame(){
        //设置为死循环，在里面判断是否跳出游戏
        while(true){
            //随机选出一个单词
            word = words[random.nextInt(words.length)];
            //创建一个和单词长度相等的Boolean型数组
            states = new boolean[word.length()];
            while(!isGameOver()){
                String str = getWord();
                System.out.print("(Guess) Enter a letter in word "+str+" :");
                String ch = In.getString();
                if(word.contains(ch)){
                    changeStates(ch);
                }else{
                    System.out.println(ch+" is not in the word");
                    misscount++;
                }
            }
            System.out.println("The word is "+word+". You missed "+misscount+" time");
            System.out.print("Do you want to guess another word? Enter y or n:");
            String chioce = In.getString();
            //判断是否退出游戏
            if(chioce.equals("y")){
                misscount = 0;
                continue;
            }else{
                break;
            }
        }
    }
    //生成当前的字符展示
    private String getWord(){
        String str="";
        for(int i=0;i<word.length();i++){
            if(states[i]){
                str += word.charAt(i);
            }else{
                str += "*";
            }
        }
        return str;
    }
    //改变Boolean型数组的状态，用false和true来判断是否带*
    private void changeStates(String ch){
        for(int i=0;i<word.length();i++){
            if((word.charAt(i)+"").equals(ch)){
                if(states[i]==true){
                    System.out.println(ch+" is already in the word!");
                    break;
                }
                states[i] = true;
            }
        }
    }
    //判断当前游戏是否结束
    private boolean isGameOver(){
        for(int i=0;i<states.length;i++){
            if(!states[i]){
                return false;
            }
        }
        return true;
    }
}

本题思路：该题其实不是很难，重点在类中的每个函数的相互关系和调用，我们用一个word字符串存储需要猜测的单词，用和word相同长度的states数组来记录是否是“*”，然后利用里面的逻辑判断来控制整个游戏的流程，但是这个类里面没有判断用户输入时的错误，这个还需要后续的改进。