一、对象与类
1、
public class VendingMachine { //定义了类 VendingMachine
//属性(变量)
int price=60;//商品价格
int balance;//余额
int total;//总钱数
//动作
void showPrompt()//初始欢迎
{
System.out.println("Welcome");
}
void insertMomey(int amount)//投进去钱数
{
balance+=amount;
}
void showBalance()//展示投进去的总钱数
{
System.out.println(balance);
}
void getFood()
{
if(balance >=price)//总钱数大于商品价格
{
System.out.println("here you are");//获取商品
balance=balance-price;//找零钱数
total=total+price;//总营业额
}
}
void sayBye()
{
System.out.println("欢迎下次光临");
}
//主函数
public static void main(String[] args) {
// TODO Auto-generated method stub
VendingMachine vm1= new VendingMachine();
vm1.showPrompt();
vm1.insertMomey(50);
vm1.showBalance();//投入了50
vm1.insertMomey(50);
vm1.showBalance();//投入了100
vm1.getFood();//得到 商品
vm1.showBalance();//找零
vm1.sayBye();
}
}
注意本地变量和类里的成员变量。
2、
题目内容：
设计一个表示分数的类Fraction。这个类用两个int类型的变量分别表示分子和分母。
这个类的构造函数是：
Fraction(int a, int b)
构造一个a/b的分数。
这个类要提供以下的功能：
double toDouble();
将分数转换为double
Fraction plus(Fraction r);
将自己的分数和r的分数相加，产生一个新的Fraction的对象。注意小学四年级学过两个分数如何相加的哈。
Fraction multiply(Fraction r);
将自己的分数和r的分数相乘，产生一个新的Fraction的对象。
void print();
将自己以“分子/分母”的形式输出到标准输出，并带有回车换行。如果分数是1/1，应该输出1。当分子大于分母时，不需要提出整数部分，即31/30是一个正确的输出。
注意，在创建和做完运算后应该化简分数为最简形式。如2/4应该被化简为1/2。
import java.util.Scanner;
public class Main {//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//定义类 Fraction
{
//成员变量
int x;
int y;
Fraction(int a,int b)//成员变量初始化，赋初值 构造函数，与类名相同
{
this.x=a;
this.y=b;
}
//成员函数，加减运算
void toDouble()//分数变小数
{
System.out.println((double)x/y);
}
Fraction plus(Fraction z)//加法
{
int n,m;
n=x*z.y+y*z.x;
m=y*z.y;
return new Fraction(n,m);//返回新的值，不影响其他的对象
}
Fraction multiply(Fraction z)//乘法
{
int n,m;
n=x*z.x;
m=y*z.y;
return new Fraction(n,m);
}
void print()//约分，除以2,3,5,7……
{
while(x%2==0 && y%2==0)
{
x=x/2;
y=y/2;
}
for(int i=3;i<=x && i<=y;i=i+2)
{
while(x%i==0 && y%i==0)
{
x=x/i;
y=y/i;
}
}
if(x==y)
System.out.println("1");
else
System.out.println(x+"/"+y);
}
}
二、对象的交互
1、Display的类
package clock;//包
public class Display {
private int value=0; //类私有变量
private int limit=0;
//公有的函数
public Display(int limit)//构造函数初始化值
{
this.limit=limit;
}
public void increase()//类加1 函数，循环函数
{
value++;
if(value==limit)
{
value=0;
}
}
public int getValue() //返回函数值
{
return value;
}
// static 静态类函数
public static void main(String[] args) {
// TODO Auto-generated method stub
Display d=new Display(24);
for(;;)//死循环
{
d.increase();
System.out.println(d.getValue());
}
}
}
2、
package clock;
public class Clock {
//调用Display类
private Display hour=new Display(24);
private Display minute=new Display(60);
//类动作
public void start()
{
minute.increase();
if(minute.getValue()==0)
{
hour.increase();
}
System.out.printf("%02d:%02d
",hour.getValue(),minute.getValue());//格式输出
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Clock clock=new Clock();
for(;;)//循环输出
{
clock.start();
}
}
}
Clock类中调用Display，生成了两个Display对象，分别表示分钟，小时。然后，在Clock类中，只需将两者交互起来就行，一定要注意，private和public。这个决定了他们是否能被调用。
3、访问属性
3.1
这里数据其实就是成员变量，操作就是那些动作，用.()调用的那些成员函数。成员函数包括（构造函数，常规函数等）。
一般来说成员变量都需要private来保护，以防止变量混乱。
带private的只能在该类下被调用，上面程序中Display中的value在Clock类中就不能被调用。
只有getValue可以调用，因为getValue 前是public。
这种情况下的成员函数变量为同类对象时，这时的private成员变量是可以访问的，因为他们对应的类是相同的。
3.2
这个是包Clock的存储结构。同一个包下，只要不是private，就都可以自由访问。
还可以看到一个文件名和类名是对应的，public class Clock，只能有一个public的类，且该类和文件名对应。
3.3
当Clock和Display不在同一个包下时，这时会看到Clock代码下会增加一行用来载入Display的类。
4、类变量和类函数
带static 的就是类变量和类函数。他们隶属于类，而与成员变量和成员函数不同，那些属于特定对象。
package Test;
public class Test11 {
public static int staticVar = 0;
public int instanceVar = 0;
public Test11() {
staticVar++;
instanceVar++;
System.out.println("staticVar=" + staticVar + ",instanceVar="
+ instanceVar);
}
public static void main(String[] args) {
Test11 test = new Test11();
Test11 test1 = new Test11();
Test11 test2 = new Test11();
}
}
无论创建多少个实例对象，永远都只分配了一个staticVar变量，并且每创建一个实例对象，这个staticVar就会加1；
但是，每创建一个实例对象，就会分配一个instanceVar，即可能分配多个instanceVar，并且每个instanceVar的值都只自加了1次。