实验1:
抽象类的练习
编写一个程序，在程序中定义一个抽象类Shape，再定义两个抽象方法Area和printArea，定义两个Shape类的子类Rectangle和Circle类，在子类中实现父类的抽象方法。
实验源程序:
//主类
public class AbstractPractice {
public static void main(String[] args) {
//实例化Rectangle的对象并传参2,4
Rectangle R = new Rectangle(9,16);
//调用Rectangle的方法printArea
R.printArea();
//实例化Circle的对象并传参2
Circle C = new Circle(6);
//调用Circle的方法printArea
C.printArea();
}
}
//抽象类Shape
abstract class Shape {
//定义抽象方法Area计算面积
abstract double Area();
//定义抽象方法printArea输出面积
abstract void printArea();
}
//Shape类的子类Rectangle类，实现父类的抽象方法
class Rectangle extends Shape {
int width,height;
//构造方法
public Rectangle(int width,int height) {
this.height = height;
this.width = width;
}
//Area方法计算矩形面积
public double Area() {
return height * width;
}
//printArea方法输出矩形面积
public void printArea() {
System.out.println("矩形的面积为：" + Area());
}
}
//Shape类的子类Circle类，实现父类的抽象方法
class Circle extends Shape {
int radius;
//构造方法
public Circle(int radius) {
this.radius = radius;
}
//Area方法计算圆形面积
public double Area() {
return radius * radius * 3.1415926;
}
//printArea方法输出圆的面积
public void printArea() {
System.out.println("圆的面积为：" + Area());
}
}
实验2:
编写下面程序写出运行结果，谈谈成员变量的继承与隐藏，方法的覆盖与重载。
实验源程序:
/*
本实验知识点主要是成员变量的继承与隐藏，方法的覆盖与重载。
首先有A类，A里面定义了三个变量，并通过构造函数对其赋值。
B类继承了A类，所以A为主类
子类B中重新赋值sum2,继承父类的变量sum,num1,num2.父类中的成员变量sum2被隐藏。
子类B中重写了父类A中的方法sum2()
*/
package FourB;
public class Practice {
public static void main(String[] args) {
//实例化B的对象m
B m=new B();
//调用父类中的sum1方法,方法继承
m.sum1();
//调用sum2方法
m.sum2();
//传参50
m.sum2(50);
//传参50
m.sum3(50);
}
}
class A{
//A类中定义sum,num1,num2
int sum,num1,num2;
//构造方法
public A() {
sum=0;
num1=10;
num2=20;
}
//定义sum1方法
void sum1() {
sum=num1+num2;
System.out.println("sum="+num1+"+"+num2+"="+sum);
}
//定义sum2方法
void sum2(int n) {
num1=n;
sum=num1+num2;
System.out.println("sum="+num1+"+"+num2+"="+sum);
}
}
//B类继承A类
class B extends A{
int num2;
//构造方法,对num2重新赋值为200
public B() {
num2=200;
}
void sum2() {
sum=num1+num2;
System.out.println("sum="+num1+"+"+num2+"="+sum);
}
//重写sum2()
void sum2(int n) {
num1=n;
sum=num1+num2;
System.out.println("sum="+num1+"+"+num2+"="+sum);
}
void sum3(int n) {
//调用父类的sum2方法,传参n
super.sum2(n);
}
}
实验3:
理解下面3个类的定义，分析它们之间的关系，写出运行结果。
实验源代码:
/*
程序中有三个类：主类、父类、子类。
主类中有主函数入口.
父类SuperClass有构造方法打印"in SuperClass:x="+x，其中x为3，和方法doSomething() ，打印"in SuperClass.doSomething()"。
子类继承了父类，在自己的构造方法中调用了一次父类SuperClass的构造方法super();并打印"in SubClass:x="+x，子类中的x为5，重写了父类的doSomething()方法，并打印"in SubClass.doSomething()"，和"super.x="+super.x+" sub.x="+x，这里的x为父类中的x=3。
*/
package FourB;
public class ClassPractice {
public static void main(String[] args) {
//实例化无参的对象，调用无参构造方法
SubClass subC=new SubClass();
//调用对象subC对象所在类的方法doSomething()
subC.doSomething();
}
}
class SuperClass{
int x;
//父类的无参构造方法
SuperClass() {
x=3;
System.out.println("in SuperClass:x="+x);
}
//父类方法
void doSomething() {
System.out.println("in SuperClass.doSomething()");
}
}
class SubClass extends SuperClass{
int x;
//子类的无参构造方法
SubClass() {
//调用父类的无参构造函数
super();
x=5;
System.out.println("in SubClass:x="+x);
}
//定义子类的方法，对父类方法进行重写
void doSomething() {
//调用父类的doSomething方法
super.doSomething();
System.out.println("in SubClass.doSomething()");
System.out.println("super.x="+super.x+" sub.x="+x);
}
}
实验4:
接口和继承的综合应用
实验源代码:
public class InterfaceInheritance {
public static void main(String[] args) {
//数组A存放参数对象
double A[]= {3,6,9,4};
//实例化对象,传参A[0]和A[1]中的值
Rectangle1 R = new Rectangle1(A[0],A[1]);
//实例化对象,传参A[2]中的值
Circle1 C = new Circle1(A[2]);
//实例化对象,传参A[3]中的值
Square S = new Square(A[3]);
//输出面积
R.printArea();
C.printArea();
S.printArea();
//计算面积之和
double sumArea = R.getArea()+C.getArea()+S.getArea();
//输出面积之和
System.out.println("面积之和为：" + sumArea);
//换行
System.out.println();
//输出周长
R.printPerimeter();
C.printPerimeter();
S.getPerimeter();
//计算周长之和
double sumPerimeter = R.getPerimeter()+C.getPerimeter()+S.getPerimeter();
//输出周长之和
System.out.println("周长之和为：" + sumPerimeter);
}
}
//抽象接口
abstract interface IShapeArea {
abstract double getArea();
}
//类Rectangle1实现接口IShapeArea
class Rectangle1 implements IShapeArea {
double width,height;
//含参构造方法
public Rectangle1(double width,double height) {
this.width = width;
this.height = height;
}
//返回面积
public double getArea() {
return width * height;
}
//返回周长
public double getPerimeter() {
return (width + height)*2;
}
//输出面积
public void printArea() {
System.out.println("矩形的面积为：" + this.getArea());
}
//输出周长
public void printPerimeter() {
System.out.println("矩形的周长为：" + this.getPerimeter());
}
}
//类Circle1实现接口IShapeArea
class Circle1 implements IShapeArea {
double radius;
//含参构造方法
public Circle1(double radius) {
this.radius = radius;
}
//返回面积
public double getArea() {
return radius * radius * 3.14159265;
}
//返回周长
public double getPerimeter() {
return radius*3.14*2;
}
//输出面积
public void printArea() {
System.out.println("圆的面积为：" + this.getArea());
}
//输出周长
public void printPerimeter() {
System.out.println("圆的周长为：" + this.getPerimeter());
}
}
//类Square继承类Rectangle1
class Square extends Rectangle1 {
double side;
//含参构造方法
public Square(double side) {
super(side, side);
this.side = side;
}
//返回面积
public double getArea() {
return side * side;
}
//返回周长
public double getPerimeter() {
return (side + side)*2;
}
//输出面积
public void printArea() {
System.out.println("正方形的面积为：" + this.getArea());
}
//输出周长
public void printPerimeter() {
System.out.println("正方形的周长为：" + this.getPerimeter());
}
}
实验5:
接口的练习
为某研究所编写一个通用程序，用来计算每一种交通工具运行1000米所需的时间，已知每种交通工具的参数都是3个整数A、B、C的表达式。现有两种工具：Car和Plane，其中Car的速度运算公式为：A*B/C，Plane的速度运算公式为：A+B+C。需要编写4类：ComputeTime、Plane、Car和接口（ICommon），要求在未来如果增加第3种交通工具的时候，不必修改以前的任何程序，只需要编写新的交通工具的程序即可，其运行过程如下，从命令行输入ComputeTime的四个参数，第一个是交通工具的类型，第二、 三、四个参数分别是整数A、B、C，我们在Dos下运行时输入如下：
实验源代码:
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class ComputeTime {
//主方法，抛出异常
public static void main(String[] args)
throws NoSuchMethodException, SecurityException, ClassNotFoundException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, InstantiationException {
//方法的参数数组
System.out.println("交通工具：" + args[0]);
System.out.println("参数A：" + args[1]);
System.out.println("参数B：" + args[2]);
System.out.println("参数C：" + args[3]);
//将string类型转换为int类型
int A = Integer.parseInt(args[1]);
int B = Integer.parseInt(args[2]);
int C = Integer.parseInt(args[3]);
//通过类名args[0]动态加载类
Class<?> i = Class.forName(args[0]);
//类i实例化对象Object T
Object T = i.newInstance();
//得到类i的指定名为Vehicle的方法m，有三个int类型的参数
Method m = i.getDeclaredMethod("Vehicle",int.class,int.class,int.class);
//invoke调用Method类代表的方法，动态调用invoke(class, method)
System.out.println("时间为：" + m.invoke(T,A,B,C));
}
}
//抽象类Plane实现接口ICommon
abstract class Plane implements ICommon {
public double Vehicle(int A,int B,int C) {
return 1000/(A+B+C);
}
}
//抽象类Car实现接口ICommon
abstract class Car implements ICommon {
public double Vehicle(int A,int B,int C) {
//除数不能为0
if(C==0) {
System.out.println("除数为0，ERROR！");
return 0;
}
else {
}
return 1000/(A*B/C);
}
}
//抽象接口
abstract interface ICommon {
abstract double Vehile(int A,int B,int C);
}
程序先通过string类型的名字获得这个类，然后用这个类实例化一个对象，找到这个对象要实现的方法，对这个方法进行调用。但最后程序发出警告，无法实现输出其后计算的值
Exception in thread “main” java.lang.InstantiationException
at java.base/jdk.internal.reflect.InstantiationExceptionConstructorAccessorImpl.newInstance(InstantiationExceptionConstructorAccessorImpl.java:48)
at java.base/java.lang.reflect.Constructor.newInstance(Constructor.java:490)
at java.base/java.lang.Class.newInstance(Class.java:584)
at ComputeTime.main(ComputeTime.java:23)
© 版权声明
文章版权归作者所有,未经允许请勿转载。
THE END
暂无评论内容