Java练习：实验三

1．编一程序，求两个正整数m、n的最大公约数。

要求程序中有两个方法，分别使用循环和递归求最大公约数，最后在主方法中分别调用这两个方法求解56与91的最大公约数。
提示：用辗转相除法。
方法：(1) 求m除n的余数r；
(2) 如果r为0，则n为最大公约数，结束。否则转(3);
(3) 用n置m，用r置n ，回到(1)。

import java.util.*;
public class Exp31 {

	public static void main(String[] args)
	{
		int m,n;
		Scanner sc= new Scanner(System.in);
		m=sc.nextInt();
		n=sc.nextInt();
		Exp31 gmf=new Exp31();
		int result=gmf.getMaxFactor1(m, n);
		System.out.println("方法1:"+result);
		int result2=gmf.getMaxFactor2(m, n);
		System.out.println("方法2:"+result2);
		
		
	}
	
	public int getMaxFactor1(int a,int b)
	{
		int r=a%b;
		if(r==0)
			return b;
		else
			return getMaxFactor1(b,r);
	}
	public int getMaxFactor2(int a,int b)
	{
		int r;
		while(a%b!=0)
		{
			r=a%b;
			a=b;
			b=r;
		}
		return b;
	}
}

2．编写一个完整的Java Application程序，其中设计一个复数类Complex，利用它验证两个复数 1+2i 和3+4i 相加产生一个新的复数 4+6i 。

复数类Complex的设计必须满足如下要求：
1）Complex 的属性有： realPart：int型，代表复数的实数部分；
maginPart：int型，代表复数的虚数部分。
2）Complex 的方法有：
Complex()：构造方法，将复数的实部和虚部都置0；
Complex(int r , int i )：构造方法，形参 r 为实部的初值，i为虚部的初值。
3）Complex complexAdd(Complex a)：将当前复数对象与形参复数对象相加，最后的结果仍是一个复数对象，返回给此方法的调用者。
4）String toString(): 把当前复数对象的实部、虚部组合成 a+bi 的字符串形式，其中a 和 b分别为实部和虚部的数据。

import java.util.*;
public class Exp32 {

	public static void main(String[] args)
	{
		Complex cplx1=new Complex(1,2);
		Complex cplx2=new Complex(3,4);
		Complex result=cplx1.complexAdd(cplx2);
		System.out.println(result.toString());
		System.out.println(cplx1.toString());
	}
	
}
class Complex{
	int realPart;
	int maginPart;
	Complex()
	{
		realPart=0;
		maginPart=0;
	}
	Complex(int r,int i)
	{
		realPart=r;
		maginPart=i;
	}
	
	public Complex complexAdd(Complex a)
	{
		Complex clx=new Complex();
		clx.realPart=this.realPart+a.realPart;
		clx.maginPart=this.maginPart+a.maginPart;
		return clx;
	}
	public String toString()
	{
		String s=this.realPart+"+"+this.maginPart+"i";
		return s;
	}
}

3．编写一个包含圆类的程序，并为圆类设计几个构造方法和一般方法，在主方法中创建一个圆类对象并输出它的周长和面积。

要求：
属性有3个：x,y,r，分别放置圆心坐标和半径；
构造方法有2个。一个是无参的，用于设置3个属性的值都为0；另一个有参的，用于设置3个属性的值，以确定一个具体的圆。
计算周长的方法：double zc()； 计算面积的方法：double mj()。

4．编写一个程序，它含有一个圆类、圆柱类和主类。

要求：
1）圆类参考上一题中的圆类；
2）圆柱类：继承圆类，并加入一个属性h(高)；
构造方法(给4个属性赋值)；
计算面积的方法(double mj())；
计算体积的方法(double tj())。
注意，要充分利用父类的方法。
3）主类：在主方法中创建圆和圆柱类的对象，然后计算并输出它们的面积及圆柱的体积。

34组成的代码：

import java.util.*;
public class Exp334 {
	public static void main(String []args)
	{
		Circle ck1=new Circle(3,3,5);
		System.out.println(ck1.zc());
		System.out.println(ck1.mj());
		cylinder yz=new cylinder(3,3,5,8);
		System.out.println("圆柱的面积:"+yz.mj());
		System.out.println("圆柱的体积:"+yz.tj());
	}

	
}

class Circle{
	int x;
	int y;
	int r;
	Circle()
	{
		x=0;
		y=0;
		r=0;
	}
	Circle(int a,int b,int c)
	{
		x=a;
		y=b;
		r=c;
	}
	public double zc()
	{
		return 3.14*2*r;
	}
	public double mj()
	{
		return 3.14*Math.pow(r,2);
	}
}

class cylinder extends Circle{
	 int h;
	 cylinder(int a,int b,int c,int d)
	 {
		 x=a;
		 y=b;
		 r=c;
		 h=d;
	 }
	 public double mj()
	 {
		 return 3.14*Math.pow(r, 2)*2+this.zc()*h;
	 }
	 public double tj()
	 {
		 return super.mj()*h;
	 }
}

5．编写一个含有5个类的程序：
类Person:
    属性：编号、姓名、性别；
    构造方法：确定编号和姓名；
    一般方法：修改编号、姓名，获取编号、姓名。
类Teacher：继承类Person并增加：
    属性：系别；
    构造方法：调用父类的构造方法；
    一般方法：修改、获取系别。
类Student：继承类Person并增加：
    属性：班级；
    构造方法：调用父类的构造方法；
    一般方法：修改、获取班级属性值。
类Classes：
    属性：班级名称，学生名单(Student类对象的数组)；
    构造方法：确定班级名称；
一般方法：建立学生名单，输出学生名单。
类Main：
     主类。主方法中创建一个班级，然后建立该班级的学生名单，最后输出学生名单。

import java.util.*;
public class Exp35 {
	public static void main(String[] args)
	{
		Classes Class=new Classes("高三13班");
		Scanner sc=new Scanner(System.in);
		System.out.println("请输入学生数量");
		int n=sc.nextInt();
		System.out.println("请输入学生的学号和姓名");
		for(int i=0;i<n;i++)
		{
			int id=sc.nextInt();
			String name=sc.next();
			Student stu=new Student(id,name);
			Class.CreateStuChart(i, stu);
		}
		Class.GetStuChart(n);
	}
}

class Person{
	int id;
	String name;
	String sex;
	Person(int id,String name)
	{
		this.id=id;
		this.name=name;
	}
	public void Update(int i,String n)
	{
		id=i;
		name=n;
	}
	public void GetInfo()
	{
		System.out.println("id:"+id+" name:"+name);
	}
}

class Teacher extends Person{
	String department;
	Teacher(int i,String name)
	{
		super(i,name);
	}
	public void Update(String department)
	{
		this.department=department;
	}
	
	public void GetInfo()
	{
		System.out.println("department:"+department);
	}
}

class Student extends Person{
	String Class;
	Student(int id,String name){
		super(id,name);
	}
	
	public void Update(String Class)
	{
		this.Class=Class;
	}
	
	public void GetInfo()
	{
		System.out.println("Class:"+Class);
	}
}

class Classes{
	String classname;
	Student []Studentchart=new Student[30];
	Classes(String classname)
	{
		this.classname=classname;
	}
	
	public void CreateStuChart(int i,Student stu)
	{
		Studentchart[i]=stu;
	}
	
	public void GetStuChart(int n)
	{
		for(int i=0;i<n;i++)
		{
			System.out.println("第"+(i+1) +"个学生:"+Studentchart[i].name);
		}
	}
	
}

6.请仔细阅读下面的程序，分析程序的结构和输出结果。再将程序上机运行，验证输出结果。（重点理解：抽象类、抽象方法、(匿名)内部类、匿名对象）

abstract class A{abstract String getS();}
class Test
{ public static void main(String args[]){
 System.out.println(new A(){ String getS(){ return "抽象？匿名？";}}.getS());
}
}

运行结果：抽象？匿名
解释：A是一个抽象类，在Test中新建了一个匿名内部类，该类继承了抽象类，重写了抽象类的方法getS()

方法中定义内部类的注意点:

• 方法中定义的类，在其它地方使用时，没有类的名字，一般用其父类来引用这样的变量。

• 同局部变量一样，方法中的内部类前面不能用public，private，protected修饰，也不能用static修饰，但可以被final或abstract修饰

• 方法中的内部类，可以访问其外部类的成员;若是static方法中的内部类，可以访问外部类的static成员。

• 方法中的内部类中，不能访问该方法的局部变量，除非是final的局部变量。

7.请仔细阅读下面的程序，分析程序的结构和输出结果。再将程序上机运行，验证输出结果。

interface I{ String getS(); }
class Test
{ public static void main(String args[]){
   System.out.println(new I(){ public String getS()
{ return "接口和内部类！";}}.getS());
 }
 }

运行结果：接口和内部类！
解释：I为一个接口，Test中使用了一个匿名内部类实现了这个接口并重写了getS()方法

匿名类的注意点：

• 这种类不取名字，而直接用其父类的名字或者它所实现的接口的名字；

• 类的定义与创建该类的一个对象同时进行，即类的定义前面有一个new，没有类的首部，对象的创建和类体共同构成一个匿名类表达式，后面以“;”结束；

• 类中不能定义构造方法，因为它没有名字。