Java 类与对象

Posted 2020-11-14 箬笠蓑衣

一、对象与类

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\\n",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次。