Java类的实现方式有哪些

六、 类与对象

一个类一个.java的文件，类名和文件名相同

1.定义一个公司类Company，包含属性name、telephone、email、product，定义一个显示属性信息的方法print。测试类中创建公司类的对象，给属性赋值，并显示公司的信息。

//Company类
public class Company {
	String name;
	String telephone;
	String email;
	String product;
	void Print(){
		System.out.println( "公司名称："+name+"\n"
				+"电话："+telephone+"\n"
				+"邮箱："+email+"\n"
				+"产品："+product);
	}
}
//测试类
public class CompanyTest {
		public static void main(String[] args) {
			Company C = new Company();
			C.name = "蓝山咖啡";
			C.telephone = "155555555";
			C.email = "[e-mail]";
			C.product = "coffee";
			C.Print();
		}
}

2.定义计算机类Computer，包含属性cpu、main_board、monitor、hard_disk、memory，重写toString方法显示Computer类属性信息。测试类中创建计算机类对象，给属性赋值，并输出相应的信息。

//Computer类
public class Computer {
	String cpu;
	String main_board;
	String monitor;
	String hard_disk;
	String memory;
	public String toString() {
		return"cpu: "+cpu+"\n"
	+"main_board: "+main_board+"\n"
	+"monitor: "+monitor+"\n"
	+"hard_disk: "+hard_disk+"\n"
	+"memory: "+memory+"\n";
	}
}
//测试类
public  class ComputerTest{
		public static void main(String[] args) {
			Computer com = new Computer();
			com.cpu = "I5";
			com.main_board = "1";
			com.monitor = "2";
			com.hard_disk = "3";
			com.memory = "4";
			System.out.println(com.toString());
		}
}

3.定义一个Friend类，包含属性name、email、address、phone，重写toString方法显示Friend类的属性信息。测试类中创建Friend类对象，给属性赋值，并输出相应的信息。

//Friend类
public class Friend {
	String name;
	String email;
	String address;
	String phone;
	public String toString() {
		return "my friend"+"\n"
				+"name:"+name+"\n"
				+"email:"+email+"\n"
				+"add:"+address+"\n"
				+"phone:"+phone;
	}
}
//测试类
public class FrinedTest{
		public static void main(String[] args) {
			Friend first = new Friend();
			first.name = "Ann";
			first.email = "[e-mail]";
			first.address = "Handan";
			first.phone = "1684687123";
			System.out.println(first.toString());
		}
}

4.定义一个账户类Account，属性money，有查询余额方法、存款方法和取款方法，其中，取款方法要进行判断，如果余额不足不能提款。测试类中模拟对一个账户的存取款及余额查询操作。

//Account类
public class Account {
	static int money;
	public static String check() {
			return "余额："+money+"元";
	}
	public static String save(int m) {
		money += m;
		return "存款后余额："+money+"元";
	}
	public static String out(int n) {
		money -= n;
		if(money>=0) {
			return "取款后余额："+money+"元";
		}
		else
			return "余额不足0元，不能提款";
	}
}
//测试类
import java.util.Scanner;
	public class AccountTest{
		public static void main(String[] args) {
			Account person = new Account();
			int action;
			System.out.println("请输入以下操作编号：");
			System.out.println("1.存款");
			System.out.println("2.取款");
			System.out.println("3.查看余额");
			System.out.println("4.退出");
			//输入动作
			Scanner in = new Scanner(System.in);
			action = in.nextInt();
			while(action!=4) {
				if(action==3) {
					System.out.println(person.check());
				}
				else if(action==2) {
					int m;
					System.out.println("请输入取款额：");
					Scanner in2 = new Scanner(System.in);
					m = in2.nextInt();
					System.out.println(person.out(m));
				}
				else if(action==1) {
					int n;
					System.out.println("请输入存款额：");
					Scanner in3 = new Scanner(System.in);
					n = in3.nextInt();
					System.out.println(person.save(n));
				}
				System.out.println("请输入后续操作编号：");
				action = in.nextInt();		//这样就可以循环做输入的动作
			}
			System.out.println("操作结束。");
		}
	}

5.编写程序模拟两个村庄：赵庄和李庄共用同一口井里的水。提示：使用static定义类变量waterAmout模拟水井的数量，在测试类中模拟两个村庄取水的动作及取水后的剩余水量。
（我感觉这道题应该有更好的写法才对）

//村庄类
public class Villages {
	static int waterAmount;
}
//测试类
import java.util.Scanner;
public class VillageTest {
	public static void main(String[] args) {
		int x,y;
		Villages.waterAmount = 5000;
		Villages zhao = new Villages();
		Villages li = new Villages();
		Scanner in1 = new Scanner(System.in);
		System.out.println("输入赵庄取水吨数:");
		x = in1.nextInt();
		System.out.println("赵庄取水"+x+"t");
		Villages.waterAmount -= x;
		System.out.println("剩余水量"+Villages.waterAmount+"t");
		
		Scanner in2 = new Scanner(System.in);
		System.out.println("输入李庄取水吨数:");
		y = in2.nextInt();
		System.out.println("李庄取水"+y+"t");
		Villages.waterAmount -= y;
		System.out.println("剩余水量"+Villages.waterAmount+"t");
	}
}

6.定义电池类Battery和收音机类Radio。Battery类包含属性batteryAmount并重写toString方法输出电池电量；Radio类包含打开收音机方法openRadio(Battery b)，假定每打开一次收音机消耗10个单位的电量。在测试类中模拟收音机消耗电池电量操作。

//Battery类
public class Battery {
	int batteryAmount;
	public String toString() {
		return batteryAmount+"%";
	}
}
//Radio类
public class Radio {
	public void openRadio(Battery b){
		b.batteryAmount -= 10;
	}
}
//测试类
public class RadioTest {
	public static void main(String[] args) {
		Battery b = new Battery();
		b.batteryAmount = 100;
        System.out.println("电池的存储电量是：" + b.toString());
        Radio radio = new Radio();
        System.out.println("打开一次收音机");
        radio.openRadio(b);
        System.out.println("收音机使用后的电量为:" + b.toString());
	}
}

七、封装和构造方法

封装快捷键：Shift+Alt +S→R

1.编写一个教材类Book，具有属性：名称（title）、页数（pageNum），其中页数不能少于200页，否则输出错误信息；具有方法：detail，用来输出每本教材的名称和页数。提示：分别给title和pageNum两个属性定义两个方法，一个方法用于设置值，一个方法用于获取值。在测试类中使用无参的构造方法创建Book对象，调用setTitle和setPageNum方法分别给title和pageNum赋值，然后输出教材的相关信息。

//Book类
public class Book {
	private String title;
	private int pageNum;
	public int setpageNum;
	public String settitle;
	public Book() {}	//无参构造
	//封装private的内容
	public String getTitle() {
		return title;
	}
	public void setTitle(String title) {
		this.title = title;
	}
	public int getPageNum() {
		return pageNum;
	}
	public void setPageNum(int pageNum) {	//在这里设置约束条件
		if(pageNum<200) {
			System.out.println("错误信息");
		}
		else
			this.pageNum = pageNum;
	}
	
	public void detail() {
		System.out.println( "教程名称："+title);
		System.out.println("页数："+pageNum);
	}
}
//测试类
public class BookTest{
	public  static void main(String[] args) {
		Book a = new Book();
		a.setPageNum(520);		//通过set*去访问调用
		a.setTitle("Java程序设计入门");
		a.detail();

		Book b = new Book();
		b.setPageNum(197);
		b.setTitle("XML");
		b.detail();
	}
}

2.编写一个Rectangle类，定义属性height、width，用构造方法为各属性赋值，要求构造方法中的形参名和成员变量名相同，使用this关键字对成员变量进行调用，然后定义一个计算矩形面积的方法getArea。测试类中输入矩形的长和宽，创建Rectangle类对象，并输出矩形的面积。

//Rectangle类
public class Rectangle {
	private int width;
	private int height;
	
	public int getWidth() {
		return width;
	}
	public void setWidth(int width) {
		if(width>0)
			this.width = width;
		else
			System.out.println("输入错误！");
	}
	public int getHeight() {
		return height;
	}
	public void setHeight(int height) {
		if(height>0)
			this.height = height;
		else
			System.out.println("输入错误！");
	}
	
	public int getArea() {
		return height*width; 
	}
}
//测试类
import java.util.Scanner;
public class RectangleTest {
	public static void main(String[] args) {
		Rectangle ju = new Rectangle();
		Scanner in = new Scanner(System.in);
		System.out.print("请输入宽：");
		ju.setWidth(in.nextInt());		//输入进set里
		System.out.print("请输入长：");
		ju.setHeight(in.nextInt());
		System.out.print("此矩形面积为：");
		System.out.println(ju.getArea());
	}
}

3.设计一个教师类Teacher，包含私有成员变量name（姓名）和workTime（工龄），利用构造函数为其中的成员变量赋值，要求构造函数中的形参名和成员变量名相同，使用this关键字对成员变量进行调用，并定义输出教师信息方法。测试类中，创建Teacher类对象，并输出教师相关信息。

//Teacher类
public class Teacher{
	private String name;
	private int workTime;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getWorkTime() {
		return workTime;
	}
	public void setWorkTime(int workTime) {
		if(workTime>0)
			this.workTime = workTime;
		else
			System.out.println("输入错误！");
	}
	
	public void xinxi() {
		System.out.println("TeacherName:"+name);
		System.out.println("WorkTime:"+workTime);
	}
}
//测试类
public class TeacherTest {
	public static void main(String[] args) {
		Teacher one = new Teacher();
		one.setName("Jack");
		one.setWorkTime(12);
		one.xinxi();
	}
}

4.设计一个学生类Student，并进行测试，要求如下：
Student类中包含姓名、成绩两个属性。分别给这两个属性定义两个方法，一个方法用于设置值，一个方法用于获取值。
Student类中定义一个无参的构造方法(不执行任何操作)和一个接收两个参数的构造方法，两个参数分别为姓名和成绩属性值。
测试类中创建两个Student对象，一个使用无参构造方法，并用setter方法给姓名和成绩赋值，另一个使用有参的构造方法，在构造方法中给姓名和成绩赋值。

//Student类
public class Student {
	private String name;
	private int grade;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getGrade() {
		return grade;
	}
	public void setGrade(int grade) {
		if(grade>0)
			this.grade = grade;
		else
			System.out.println("输入错误！");
	}
	public Student() {}		//无参构造方法	
	
	public void setter() {
		System.out.println("name:"+name);
		System.out.println("grade:"+grade);
	}
	
	public Student(String name,int grade) {		//有参构造方法	
		this.name = name;
		this.grade = grade;
	}
}
//测试类
public class StudentTest {
	public static void main(String[] args) {
		Student stu1 = new Student();
		stu1.setName("Lili");
		stu1.setGrade(94);
		stu1.setter();
		
		Student stu2 = new Student("Ami",99);
	    System.out.println("name:"+stu2.getName()+"\n"+"grade:"+stu2.getGrade());
	}
}

5.编写一个类Point，代表第一象限内的点（坐标轴上的点除外）。
类Point具有属性：横坐标（x）、纵坐标（y）；
若x和y都大于零则输出：点在第一象限内，坐标为：(34,45)；
否则输出：点应该在第一象限内，请重新输入！
在测试类中使用无参的构造方法创建Point对象，调用setX和setY方法分别给属性x和y赋值，然后输出点的相关信息。

//Point类
public class Point {
	private int x;
	private int y;
	
	public int getX() {
		return x;
	}
	public void setX(int x) {
		if(x>0)
			this.x = x;
		else
			System.out.println("点应该在第一象限内，请重新输入!");
	}
	public int getY() {
		return y;
	}
	public void setY(int y) {
		if(y>0)
			this.y = y;
		else
			System.out.println("点应该在第一象限内，请重新输入!");
	}
	public Point() {}
	public void set() {
		System.out.println("("+x+","+y+")");
	}
}
//测试类
public class PointTest {
	public static void main(String[] args) {
		Point p = new Point();
		p.setX(18);
		p.setY(75);
		p.set();
	}
}

6.编写一个类Person，类Person包含
属性：
私有实例变量name（姓名）、类变量count（人数）；
方法：
构造方法public person( )： 仅自增count；
构造方法public person(String name)：自增count并为name赋值；
方法public String getName( )：获取私有属性name的值;
方法public void print( )：输出Person类实例化的对象是第几个人，若name为空，则默认为“无名氏”。

//Person类
public class Person {
	private String name;
	static int count=0;
	public int person() {
		return count++;
	}
	public Person(String name) {
		count++;
		this.name=name;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		if(name==null)
			this.name = "无名氏";
		else
			this.name = name;
	}
	public void print( ) {
		System.out.println("第"+count+"个人，姓名为"+name);
	}
}
//测试类
public class PersonTest {
	public static void main(String[] args) {
		Person p1 = new Person("苏三");
		p1.print();
		Person p2 = new Person("清雅");
		p2.print();
		Person p3 = new Person("素衣");
		p3.print();
		Person p4 = new Person("白染");
		p4.print();
	}
}

八、继承

关键字：extends
知识点：super | this | final

1.设计一个学生类Student和它的一个子类Undergraduate，要求如下：
Student类有name和age两个属性，一个包含两个参数的构造方法，用于给name和age赋值，一个show()方法打印Student的属性信息。
本科生类Undergraduate增加一个degree属性。有一个包含三个参数的构造方法，前两个参数用于给继承的name和age属性赋值，第三个参数给degree专业赋值，一个show()方法用于打印Undergraduate的属性信息。
测试类中分别创建Student对象和Undergraduate对象并调用它们的show()方法。

//父类Student
public class Student {
	String name;
	int age;
	public Student() {}
	public Student(String name,int age) {
		this.name = name;
		this.age = age;
	}
	public void show() {
		System.out.println("name:"+name+"\n"+"age:"+age);
	}
}
//子类Undergraduate 继承 父类Student
public class Undergraduate extends Student{
	String degree;
	public Undergraduate() {}
	public Undergraduate(String name,int age,String degree) {
		this.name = name;
		this.age = age;
		this.degree = degree;
	}
	public void show() {
	System.out.println("name:"+name+"\n"+"age:"+age+"\n"+"degree:"+degree);
	}
}
//测试类
public class UndergraduateTest {
	public static void main(String[] args) {
		Student s1 = new Student();
		Undergraduate s2 = new Undergraduate();
		s1.name = "Li";
		s1.age = 18;
		s1.show();

		s2.name = "Dacy";
		s2.age = 19;
		s2.degree = "邯郸学院";
		s2.show();
	}
}

2.交通工具的类继承
父类Vehicles
属性：名称，颜色，座位；方法：showDetail( )显示名称，颜色，座位
子类Car
调用Vehicles类（父类）方法showDetail( )显示名称，颜色，座位
调用Car类方法show( )输出小汽车的独特行为（如：“不能拉货用”等）

//父类Vehicles
public class Vehicles {
	String name;
	String color;
	int seat;	
	public Vehicles() {}
	public void showDetail(String name,String color,int seat) {
		System.out.println("名称："+name+"   颜色:"+color+"  座位："+seat);
	}
}
//子类Car 继承 父类Vehicles
public class Car extends Vehicles{
	String act;
	public Car() {
		act = "不能拉货";
	}
	public void show() {
		System.out.println("独特行为："+act);
	}
}
//测试类
public class VehiclesTest {
	public static void main(String[] args) {
		Car car = new Car();
		car.act = "只能带人";
		car.showDetail("长安马自达", "red", 4);
		car.show();
	}
}

3.开发教师类，其中教师分为Java教师以及.NET教师，各自的要求如下：
Java教师
属性：姓名、专业方向等字段；
方法：授课（步骤：打开Eclipse、实施理论课授课）、自我介绍
.NET教师
属性：姓名、专业方向
方法：授课（步骤：打开Visual studio 2005、实施理论课授课）、自我介绍

//父类Teacher
public class Teacher {
	String name;
	String major;
	public void introduce() {
		System.out.println("自我介绍：大家好！我是"+name+"，今后会教"+major+"，很高兴认识你们！");
	}
}

//子类Java 继承 父类Teacher
public class Java extends Teacher{
	public Java() {}
	public Java(String name) {
		this.name = name;
		major = "JAVA";
	}
	public void teach() {
		System.out.println("授课步骤：");
		System.out.println("1.打开Eclipse");
		System.out.println("2.实施理论课授课");
	}
}
//子类NET 继承 父类Teacher
public class NET extends Teacher{
	public NET() {}
	public NET(String name) {
		this.name = name;
		major = ".NET";
	}
	public void teach() {
		System.out.println("授课步骤：");
		System.out.println("1.打开Visual studio 2005");
		System.out.println("2.实施理论课授课");
	}
}
//测试类
public class TeacherTest {
	public static void main(String[] args) {
		Java teacher1 = new Java("Lin");
		teacher1.introduce();
		teacher1.teach();
		System.out.println();
		NET teacher2 = new NET("Lucy");
		teacher2.introduce();
		teacher2.teach();
	}
}

4.假设银行(Bank)按整年year（只能取正整数）计算利息，利息计算公式为：
interest=year0.35savedMoney ，其中savedMoney 为存款
中国建设银行(ConstructionBank)重写了计算利息的方法，整年利息计算方式同银行，不足整年的部分按每天0.0001的利率计算。利用继承、方法重写、super关键字等知识编写程序。

//父类Bank
public class Bank {
	private float savedMoney;
	private int day;
	public float getSaveMoney() {
		return savedMoney;
	}
	public void setSaveMoney(float savedMoney) {
		this.savedMoney = savedMoney;
	}
	public int getDay() {
		return day;
	}
	public void setDay(int day) {
		this.day = day / 365;
	}
	public double money(int year,float savedMoney) {
		return day*0.35*savedMoney;
	}
}
//子类ConstructionBank 继承 父类Bank
public class ConstructionBank extends Bank{
	public double money(int day,float savedMoney) {
		if(day%365==0)
			return day/365*0.35*savedMoney;
		else {
			return day/365*0.35*savedMoney+day%365*0.0001*savedMoney;
		}
	}
}
//测试类
public class ConstructionBankTest {
	public static void main(String[] args) {
		ConstructionBank person1 = new ConstructionBank();
		System.out.println(person1.money(375, 10000));
	}
}

5.定义类A，创建类A的对象，给属性赋值，并输出相应的信息。
类A包括：
圆周率；
final方法speak( )，用来输出“您好！”；
方法getArea( )，用来计算并返回圆面积；

//A类
public class A {
	final double PI = 3.1415;
	private double r;
	
	public double getR() {
		return r;
	}
	public void setR(double r) {
		if(r>0)
			this.r = r;
		else
			System.out.println("数据错误");
	}
	final void speak() {
		System.out.println("您好！");
	}
	public double getArea() {
		double area = r*r*PI;
		return area;
	}
}
//测试类
public class ATest {
	public static void main(String[] args) {
		A a = new A();
		a.setR(2);
		a.speak();
		System.out.println("此圆的面积为："+a.getArea());
	}
}