Java 类与对象、继承、实例成员与类成员、接口、abstract修饰符的使用

最新推荐文章于 2022-09-03 14:33:46 发布

薄荷°

最新推荐文章于 2022-09-03 14:33:46 发布

阅读量766

点赞数 1

文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/qq_53334934/article/details/121050395

版权

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)  //a, b, c构成三角形的条件表达式
     { boo=true;  // 给boo赋值
     }    
     else
     { boo=false; // 给boo赋值
     }
   }
   double getLength() 
   { length=sideA+sideB+sideC;
     return length;  // 方法体，要求计算出length的值并返回
   }
public double  getArea() 
   {    if(boo)
        { double p=(sideA+sideB+sideC)/2.0;
          area=Math.sqrt(p*(p-sideA)*(p-sideB)*(p-sideC)) ;
          return area;    }
      else
        { System.out.println("不是一个三角形,不能计算面积");
          return 0; }
   } 
   public void setABC(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)  // a, b, c构成三角形的条件表达式
      { boo=true;   //给boo赋值。
      } 
else
      { boo=false;  // 给boo赋值
      }
   }
   public double getA()
  {
      return sideA;
  }
}
class Lader 
{   double above,bottom,height,area; 
    Lader(double a,double b,double h)
    {above=a;bottom=b;height=h; // 方法体
    }
    double getArea( )
    { area=(above+height)*height*0.5; 
      return area;  // 方法体，,要求计算出area返回
    }
} 
class Circle 
{   double radius,area;
    Circle(double r)
    { radius=r; //方法体
    }
    double getArea( ) 
    {  area=3.14*radius*radius;
       return area; //方法体，要求计算出area返回
    }
    double getLength( ) 
    {
      return 2*3.14*radius;  //getArea方法体的代码,要求计算出length返回
    }
void setRadius(double newRadius)
    {  radius=newRadius;
    }
    double getRadius( ) 
    { return radius;
    }
}

public class AreaAndLength    //此类可以理解为主函数，运行时需将文件名命名为AreaAndLength
{  
    public static void main(String args[ ])
    {  double length,area;
       Circle circle=null;
       Triangle triangle;
       Lader lader;
       circle=new Circle(4.0);  //创建对象circle
       triangle=new Triangle(3.0,4.0,5.0);  //创建对象triangle
       lader=new Lader(2.0,4.0,3.0);  //创建对象lader
        length=circle. getLength( ) ; // circle调用方法返回周长并赋值给length
        System.out.println("圆的周长:"+length); 
        area= circle. getArea( ) ;// circle调用方法返回面积并赋值给area
        System.out.println("圆的面积:"+area); 
        length=triangle.getLength( );  // triangle调用方法返回周长并赋值给length
        System.out.println("三角形的周长:"+length); 
        area=triangle.getArea( );  // triangle调用方法返回面积并赋值给area
        System.out.println("三角形的面积:"+area); 
        area=lader.getArea( );  // lader调用方法返回面积并赋值给area
        System.out.println("梯形的面积:"+area); 
        triangle.setABC(12,34,1);// triangle调用方法返修改三个边的代码，要求将三个边修改为12，34，1
        area=triangle.getArea();// triangle调用方法返回面积并赋值给area
        System.out.println("三角形的面积:"+area); 
        length=triangle.getLength( );  // triangle调用方法返回周长并赋值给length
        System.out.println("三角形的周长:"+length);
    }
}

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<employee.length;i++)
       {
           if(i%3==0)
             employee[i]=new WeekWorker( );
           else if(i%3==1)
             employee[i]=new MonthWorker( );
           else if(i%3==2)
             employee[i]=new YearWorker( );
       } 
     Company company=new Company(employee);
     System.out.println("公司年工资总额:"+company.salariesPay( ) );
   }
}

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<z){
s=z;}
return s;
}
public static void main(String a[ ]){    //执行类方法
    MinMax m=new MinMax();
    System.out.println("最小值"+m.Min(4.5,5.5));
    System.out.println("最大值"+m.Max(3.4,3.7,2.2));
}
}

①定义一个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);
}
}

输出为

薄荷°

关注

1
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
Java 类与对象、继承、实例成员与类成员、接口、abstract修饰符的使用

Java中类与对象的写法与C、C++相似一、类与对象编写一个Java Application程序，该程序中有3个类：Triangle，Lader 和Circle，分别用来刻画“三角形”、“梯形”和“圆形”。Triangle类：具有类型为double的三个边、周长、面积属性，具有返回周长、面积以及修改三个边的功能。另外，还具有一个boolean类型的属性，该属性用来判断三个数能否构成一个三角形。 Lader类：具有类型为double的上底、下底、高、面积属性，具有返回面积的功能。 Circle
复制链接

扫一扫