JAVA 短裤

---

Week one: 类（class)与对象(object)

1.1 创建一个对象（new an object）

VendingMachine vm = new VendingMachine();
//VendingMachine:           			  --->(Class名/类似于一种类型：int, double...)
//vm:                        			  --->对象名
//new VendingMachine();     			  --->构造一个对象

1.2 定义类（define a class)

1.3 成员变量（Member variables）与成员函数（Member function）

• this：
  成员函数的一个特殊的固有的本地变量，它表达了调用这个函数的那个对象

本地变量	成员变量
函数内部	函数外部，类里的

1.4 对象初始化 （initialize an object）

• 构造函数：

public class ClassName{
	ClassName(){
		...
	}
}

1.是一个名字和类名字相同的成员函数
2.构造对象时自动调用，来给对象初始化
3.不用带返回类型
4.可以有参数，也可以无参数
tips:不能有返回类型

• 重载（关系）：
  一个class里可以有多个构造函数（只要参数表不同），构造对象时，根据给出的参数，自动匹配对应的构造函数
• Java提供了多种手段来保障对象创建时的初始化，包括给每个成员变量默认的“0”值、定义初始化和构造函数。

---

Homework:

Q:

---

A:

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		Fraction a = new Fraction(in.nextInt(),in.nextInt());
		Fraction b = new Fraction(in.nextInt(),in.nextInt());
		a.print();
		b.print();
		a.plus(b).print();
		a.multiply(b).plus(new Fraction(5,6)).print();
		a.print();
		b.print();
		in.close();
	}
}

class Fraction {
	int x, y;
	public Fraction(int a, int b){
		this.x = a;
		this.y = b;
	}
	
	public double toDouble() {
		double r = (double)x / (double)y;
		return r;
	}
	
	public Fraction plus(Fraction r) {
		int x1, y1;		//新分数的分子x1，分母y1
		y1 = y * r.y;
		x1 = x * r.y + r.x * y;
		Fraction n = new Fraction(x1, y1);
		return n;
	}
	
	public Fraction multiply(Fraction r) {
		int x1, y1;
		y1 = y * r.y;
		x1 = x * r.x;
		Fraction n = new Fraction(x1, y1);
		return n;
	}
	
	void print() {
		int x1 = x, y1 =y;
		if(x1 == y1) {
			System.out.println(1);
		}
		else {
			for(int i=2; i<=x; ++i) {
				if(x%i == 0 && y%i == 0) {
					x1 = x/i;
					y1 = y/i;
				}
			}
			System.out.println(x1 + "/" + y1);
		}
	}
}

---

Week TWO: 对象(object)交互

2.1 对象交互

1. 对象化：识别组成元素，抽象出属性，建立对象

一个时钟：

1. Display类: (时针：2位数，分针：2位数 → 抽象出一个类：2位的计数器)

应该包含：

• 变量（属性）：
  1）值value ；
  2）上限limit ；
• 函数（功能）：
  1）构造函数（生产对象，并初始化）Display ；
  2）值自动增加（达到上限后重置，归0）increase ；
  3）得到值（可视化）getValue

2. Clock类:

• 变量（属性）：

1. Display对象.时针hour
2. Display对象.分针minute
   →对象间互动：分针达到limit后，让时针++；

• 函数（功能）：

1. 时钟运转起来start

package clock;

public class Display {
	private int value = 0;
	private int limit = 0;
	
	public Display(int limit) {
		this.limit = limit;
	}
	
	public void increase() {
		value++;
		if(value == limit) {
			value = 0;
		}
	}
	
	public int getValue() {
		return value;
	}
	
	public static void main(String[] args) {
		Display d = new Display(24);
		for(;;) {
			d.increase();
			System.out.println(d.getValue());
		}
		
	}

}

package clock;

public class Clock {
	private Display hour = new Display(24);
	private Display minute = new Display(60);
	
	public void start() {
		while(true) {
			minute.increase();
			if(minute.getValue() == 0) {
				hour.increase();
			}
			System.out.printf("%02d:%02d\n", hour.getValue(), minute.getValue());
			//%02d:输出2位整数，如果只有1位，用0填充
		}
	}
	
	public static void main(String[] args) {
		Clock clock = new Clock();
		clock.start();
	}

}

2.2 访问属性

1. 封装：所有成员变量必须是private（私有）的，避免被乱改

2. private: 私有变量，只能在类里使用（在main里也可以使用），类外面不可见

   可以通过类中的非private函数间接访问，修改

私有是针对类，而不是对象

3. public: 公有

公有类必须和文件名相同，私有类可以不同

3. 没加private/public: friendly 和它位于同一个package的其他类可以访问，出了这个package就没用了
4. 编译单元：一个.java文件，一个编译单元内只能由一个public类

2.3 包（package）

类的管理机制

1. import: 用另一个包里的类

import package.Class;

2. 包的层级关系：

  import package1.package2.Class;
  //导入包1中的包2中的Class

2.4 类变量

1. static：类变量，不属于任一对象，属于这个类，初始化只能做一次（装载时）

   • 两种访问方式：

     ​ 1）通过类访问：Class.value

     2）通过类的对象访问：obj.value

2. static的函数只能调用static的函数，访问static的变量，不能直接访问非static

Homework:

Q:

A:

class Display {
	private int value;
	private int limit;
	
	public Display(int limit, int value) {
		this.limit = limit;
		this.value = value;
	}
	
	public void increase() {
		value++;
		if(value == limit) {
			value = 0;
		}
	}
	
	public int getValue() {
		return value;
	}
}
	
class Clock {
	private Display hour;
	private Display minute;
	private Display second;
	
	public Clock(int hour, int minute, int second) {
		this.hour = new Display(24, hour);
		this.minute = new Display(60, minute);
		this.second = new Display(60, second);
	}
	
	public void tick() {
		//System.out.println("tick");
		second.increase();
		if(second.getValue() == 0) {
			minute.increase();
			if(minute.getValue() == 0) {
				hour.increase();
			}
		}
	}
	
	public String toString() {
		return (String.format("%02d:%02d:%02d", hour.getValue(), minute.getValue(), second.getValue()));
	}
}
	
public class Main{
	
	public static void main(String[] args) {
		java.util.Scanner in = new java.util.Scanner(System.in);
		Clock clock = new Clock(in.nextInt(), in.nextInt(), in.nextInt());
		clock.tick();
		System.out.println(clock);
		in.close();
	}
}

还可以在Display类里写一个setValue函数，来初始化value：

public void setValue(int value) {
        this.value=value;
    }

Cloak类里：

private Display hour=new Display(24);
    private Display minute=new Display(60);
    private Display second=new Display(60);
    Clock(int hour, int minute, int second){
        this.hour.setValue(hour);
        this.minute.setValue(minute);
        this.second.setValue(second);
    }