Java中类与对象的写法与C、C++相似
一、类与对象
编写一个Java Application程序，该程序中有3个类：Triangle，Lader 和Circle，分别用来刻画“三角形”、“梯形”和“圆形”。
- Triangle类：具有类型为double的三个边、周长、面积属性，具有返回周长、面积以及修改三个边的功能。另外，还具有一个boolean类型的属性，该属性用来判断三个数能否构成一个三角形。
- Lader类：具有类型为double的上底、下底、高、面积属性，具有返回面积的功能。
- Circle类：具有类型为double的半径、周长和面积属性，具有返回周长、面积的功能
文件命名为AreaAndLength.java。
class Triangle
{ double sideA,sideB,sideC,area,length;
boolean boo;
public Triangle(double a,double b,double c)
{ sideA=a;sideB=b;sideC=c; // 参数a, b, c分别赋值给sideA, sideB, sideC
if(sideA+sideB>sideC && Math.abs(sideA-sideB)sideC && Math.abs(sideA-sideB)
class类基本格式
class 类名{
double/int/string //类变量
类名(){
} //构造函数
其他方法
}
主函数调用时
public class 类名 //此类可以理解为主函数，运行时需将文件名命名为此public类的类名
{
public static void main(String args[ ])
{
Circle circle=null;
circle=new Circle(4.0); //创建对象circle
length=circle. getLength( ) ; // circle调用方法返回周长并赋值给length
System.out.println("圆的周长:"+length);
}
}
注意：boolean类型变量其值为true或者false
二、继承
有一个abstract类，类名为Employee。Employee的子类有YearWorker，MonthWorker和WeekWorker。YearWorker对象按年领取薪水，MonthWorker按月领取薪水，WeekWorker按周领取薪水。Employee类有一个abstract方法：public abstract earnings(); 子类必须重写父类的earnings()方法，给出各自领取报酬的具体方式。
有一个Company类，该类用employee数组作为成员，employee数组的单元可以是YearWorker对象的上转型对象、MonthWorker 对象的上转型对象或WeekWorker对象的上转型对象。程序能输出Company 对象一年需要支付的薪水总额。
将源文件保存为HardWork.java。
abstract class Employee
{
public abstract double earnings( );
}
class YearWorker extends Employee
{
public double earnings( )
{ return 3000.0;
}
// 重写earnings( )方法
}
class MonthWorker extends Employee //类的继承，用extends+父类名表示
{
public double earnings( )
{ return 6000.0;
}
// 重写earnings( )方法
}
class WeekWorker extends Employee
{
public double earnings( )
{ return 9000.0;
} // 重写earnings( )方法
}
class Company
{
Employee[ ] employee;
double salaries=0;
Company(Employee[ ] employee)
{
this.employee=employee;
}
public double salariesPay( )
{
salaries=0;
for(int i=0;i<20;i++){
salaries+=employee[i].earnings( );
}// 计算salaries
return salaries;
}
}
public class HardWork
{
public static void main(String args[ ])
{
Employee[ ] employee=new Employee[20];
for(int i=0;i
abstract抽象类
用abstract修饰的类为抽象类，抽象类不能被实例化。
用abstract修饰的方法为抽象方法，抽象方法没有方法体。
抽象方法必须有子类实现
详见 java abstract修饰符_say_haha的博客-CSDN博客_javaabstract修饰符
三、实例成员与类成员
import java.util.Scanner;
class A
{ float a; // 声明一个float型实例变量：a
static float b; // 声明一个float型类变量：b
void setA(float a)
{ this.a=a; // 将参数a的值赋值给成员变量a
}
void setB(float b)
{ this.b=b; // 将参数b的值赋值给成员变量b
}
float getA( )
{ return a;
}
float getB( )
{ return b;
}
void inputA( )
{ System.out.println(a);
}
static void inputB( )
{ System.out.println(a);
}
}
public class Example
{ public static void main(String args[ ])
{ A s;
s=new A( );
s.setB(100);// 通过类名操作类变量b,并赋值100
s.inputB( ); // 通过类名调用方法inputB( )
A cat=new A( );
A dog=new A( );
cat.setA(200); // cat象调用方法setA(int a)将cat的成员a的值设置为200
cat.setB(400); // cat调用方法setB(int b)将cat的成员b的值设置为400
dog.setA(200); // dog象调用方法setA(int a)将dog的成员a的值设置为200
dog.setB(400);// dog调用方法setB(int b)将dog的成员b的值设置为400
cat.inputA();// cat调用inputA( )
cat.inputB();// cat调用inputB( )
dog.inputA();// dog调用inputA( )
dog.inputB();// dog调用inputB( )
}
}
问题
①将inputA()方法中的System.out.println(a);改写为System.out.println(a+b);编译是否出错？为什么？
没有。b为float型类变量，且为静态（static）
②将inputB()方法中的System.out.println(b);改写为System.out.println(a+b);编译是否出错？为什么？
出错了。
Example.java:21: 错误: 无法从静态上下文中引用非静态 变量 a
{ System.out.println(a+b);
^
1 个错误
static方法与类有关、与实例无关
静态初始化 static{语句。。。} 先于实例的初始化
四、接口
①定义一个接口，它含有两个抽象方法：第一个抽象方法用于实现在两个数中求最小的数；第二个抽象方法用于实现在三个数中求最大的数；
- 定义一个类实现这个接口；
- 再定义一个含有main（）方法的主类,实现最小和最大的数的输出。
interface A{ //接口A
double Min(double a,double b);
double Max(double x,double y,double z);
}
public class MinMax implements A{ //创建函数MinMax来定义方法Min、Max
public double Min(double a,double b){
if(a>b){
return b;
}
else
return a;
}
public double Max(double x,double y,double z){
double s;
if(x>y){
s=x;}
else
s=y;
if(s
①定义一个StartStop接口，含有start()和stop()两个抽象方法；
- 分别创建“会议”和“汽车”两个类实现StartStop接口；
- 定义测试类，利用接口StartStop定义一个数组，创建一个“会议”对象和一个“汽车”对象赋值给数组，通过数组元素访问对象的start()和stop()方法。
interface StartStop{ //创建接口命名为StartStop
abstract void start();
abstract void stop();
}
class Meeting implements StartStop{
public void start(){
System.out.println("会议开始");
}
public void stop(){
System.out.println("会议结束");
}
}
class Car implements StartStop{
public void start(){
System.out.println("发动引擎");
}
public void stop(){
System.out.println("熄火");
}
}
public class MeetingCar{ //创建一个public类，并将文件名命名为MeetingCar
public static void main(String a[]){
StartStop[] s; //定义StartStop类型数组s
s=new StartStop[2]; //给s分配两个空间
Meeting meet;
Car car;
meet=new Meeting();
car=new Car(); //分别给s[0]、s[1]赋值为Meeting、Car
s[0]=meet;
s[1]=car;
s[0].start(); //执行方法（注意要加括号）
s[0].stop();
s[1].start();
s[1].stop();
}
}
结果为
1、参看UML图，编写类Shape和Triangle，实现类中的方法（斜体字是抽象方法）,并自定义构造函数、get、set等方法。
abstract class Shape{
double area;
Shape(){ }
public abstract double getArea();
public String toString(){
return "Area";
}
}
class Triangle extends Shape{
double side1,side2,side3;
Triangle (double sideA,double sideB,double sideC){
side1=sideA;
side2=sideB;
side3=sideC;
}
public double getArea(){
double p=(side1+side2+side3)/2.0;
area=Math.sqrt(p*(p-side1)*(p-side2)*(p-side3)) ;
return area;
}
public String toString(){
return "Area:"+area;
}
}
class Circle extends Shape{
double radius;
Circle(double r){
radius=r;
}
public double getRadius(){
return radius;
}
public double getArea(){
area=3.14*radius*radius;
return area;
}
public boolean equals(Object anobject){
Circle an=(Circle) anobject;
if(this.radius ==an.getRadius()){
System.out.println("equal");
return true;
}
else
System.out.println("unequal");
return false;
}
public String toString(){
return "Area:"+area;
}
}
public class Shapes
{
public static void main(String args[ ])
{
Triangle tri;
Circle cir;
tri=new Triangle(3.0,4.0,5.0);
cir=new Circle(4.0);
tri.getArea();
System.out.println(tri.toString());
cir.getArea();
System.out.println(cir.toString());
Circle c1;
c1=new Circle(4.0);
c1.equals(cir);
Circle c2;
c2=new Circle(5.0);
c2.equals(cir);
}
}
输出为
