2021 JAVA期末复习（编程题）2

最新推荐文章于 2024-03-22 03:29:35 发布

icejuhua

最新推荐文章于 2024-03-22 03:29:35 发布

阅读量1k

点赞数 3

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

本文链接：https://blog.csdn.net/qq_53958979/article/details/122060941

版权

类与对象：

1.知识点：

1.java是一门面向对象的编程语言

2.类的声明和实例化：

每个项目中一定要有一个类有main方法作为程序的主入口

public static void main(String[] args){


}

2.1普通类

例子：用户类的创建（ID，名字，密码）,对应的成员变量的get set方法

类的声明：关键字class

class User_t(类名){
   //如果写了有参构造函数需要自己定义无参构造函数
     public User(){
                
        this.ID = "0";
        this.name = "0";
        this.pwd = "0";
    }
    //有参构造函数，通过有参构造函数在实例化对象时能够给该对象基本的属性
    public User(String ID, String name , String pwd){
        this.ID = ID;
        this.name = name;
        this.pwd = pwd;
        

//    可以定义自定义的方法，一般是为公共的方法
    }
    //各个成员的get 
    public String getID(){
        return this.ID;
    }
    public String getName(){
        return this.name;
    }
    public String getPwd(){
        return this.pwd;
    }
//    set 方法
       
    public void setID(String ID){
        this.ID = ID;
    }
    public void setName(String name){
        this.name= name;
    }
    public void setPwd(String pwd){
        this.pwd= pwd;
    }
 //类中的成员变量一般是私有变量，保证安全性，如果要调用一般会用对应的get set方法（自己定义）
    private String ID;
    private String name;
    private String pwd;

   




}

类中方法的调用

对象名.方法名();
eg:
//u1为类user创建的对象，调用setPwd方法，给u1中的成员变量Pwd赋值为123456;
u1.setPwd("123456");

一个class只能有一个公共类,公共了类的名字必须和该文件名字相同

如果不是公共的类不同包中不能互相访问，所以一般一个类一个文件

如果需要公共类互相引用，需要在头文件中加上包的引用

//引入lab01包中所有的类
import lab01.*;
//引入lab01包中特定的user2类

import lab01.user2;

类中可以申明内部类，方法和上面的申明类似。这里讲一下使用方法

方法1：


外部类.内部类 对象名 = new 外部类().new 内部类();
内部类.方法();

方法2：

外部类 对象1 = new 外部类();
外部类.内部类 对象2 = 对象1.new 内部类();
内部类.方法();

2.2抽象类：

概念：

抽象类常常用来表示对问题领域进行分析、设计过程中得出的抽象概念，是对一系列看上去不同，但本质相同的具体概念的抽象

抽象方法：

抽象方法是只有方法头的函数，但是没有实现函数实例化，一般申明方式是：abstract 抽象方法名(); 。抽象方法只能在抽象类中定义，但是抽象类可以定义普通方法

抽象类的定义：

abstract class 类名{
    //声明成员变量
    //定义构造方法
    //定义一般方法
    //定义抽象方法
}

注意点：

抽象类可以有构造函数

抽象类不能通过new实例化对象，但是可以作为数据类型创建变量，然后再通过继承的子类进行new实例化

抽象类一般需要子类进行继承，继承的子类必须要实现父类中所有的抽象方法。

不能用abstract修饰构造方法、静态方法和私有方法

即使子类的父类是具体的，这个子类也可以是抽象的

子类可以覆盖父类的方法并将它定义成abstract

3.类的继承：

将子类中共有的代码提取到父类中，再由子类来继承以实现代码的优化（解决代码冗余）

一个子类只能有一个直接父类，但是一个父类可以有很多个子类。如果想要继承多个父类，需要使用接口类，后面会提到。

子类继承的定义

class <子类名> extends <父类名>{...}

具体例子：
public class Data extends faData{
    public Data(String ID,String name){
        super(ID,name);
    }
    public void prit(){
        System.out.println(super.ID+this.name);
    }

}

子类可以继承所有父类中的方法和非prviate的成员

如果子类想调用父类成员或者方法就要用super.

调用父类的构造方法，就要在子类的构造方法中第一行用super(构造方法具体的参数)

 public Data(String ID,String name){
        super(ID,name);
    }

调用父类构造方法要遵循的原则：

- 若父类是无参构造方法，则**子类无条件调用该构造方法**

- 若子类无自己的构造方法，则调用父类的无参构造方法作为自己的构造方法

- 若子类有自己的构造方法，则在创建子类对象时**先调用并执行父类的无参构造方法**，然后再执行自己的构造方法。

成员方法的重写(覆盖)

定义：在子类中可以重新定义继承的方法，称为成员方法的重写。

通过方法的重写，可以使一个方法在不同的子类中表现出不同的行为

调用被重写的父类方法： `super.方法名(实例参数)`

重写方法应遵循的规则：

重写方法应与父类有完全相同的方法名，返回值和参数列表**

重写方法不能比它所重写的方法访问性更低**

(public > protected > default > private)

重写方法不能比它所重写的方法抛出更多的异常

子类不能重写父类中声明为final或static的方法

子类不能重写父类中声明为private的方法，否则只是在子类内新定义了一个方法

4.接口的定义以及用法

接口中都是抽象方法，接口是一个抽象类，

接口相比抽象类具有更好的特性：

- 可以被多继承
- 设计和实现完全分离
- 更自然的使用多态
- 更容易搭建程序框架
- 更容易更换实现

接口的定义

[修饰符] interface 接口名 extends 父接口名表{
    //常量声明 //常量修饰符都是 public static final //可以不写
    //抽象方法声明  //方法的修饰符都是 public abstract //可以不写
}

接口的特性：

- 一个接口可以有一个以上的父接口（即多继承）
- 接口**没有构造方法，不能被实例化**
- 接口只能定义常量和抽象方法
- 实现类必须实现接口的所有方法，修饰符必须是public
- 实现类可以实现多个接口

接口的例子：

interface inter1{
    public abstract String getString();//抽象方法
    void putString();//可以不加修饰符的抽象方法
    public static final int a = 1;//定义常量 一定要初始化值，并且值不能修改
    int b = 10;//省略修饰符的常量定义
}

接口也可以继承接口，能多继承关键词函数extends

interface inter1 extends inter2,inter3{
...
}

接口的实现

实现接口用于实现父接口的抽象方法

注意：实现接口时使用的继承语句为`implements`而不是`extends`

接口本身不可以实例化，但是接口可以作为类型声明变量，然后通过`new 实现类名`来完成实例化

public intface UsbInterface{
    //USB接口提供服务.
    void service();
}//编写接口
public class UDisk implements UsbInterface{//编写实现类实现接口 若有多个接口使用 ， 分隔
    public void service(){
        System.out.println("连接USB接口，开始传输数据");
    }
}

UsbInterface uDisk = new UDisk();
uDisk.service();

可以进行多接口的实现

class 类名 implements 接口1,接口2,接口3...接口n{...}

2.例题

1.设计一个风扇类Fan。这个类包括：

（1）一个名为speed的int类型成员变量表示风扇的速度，默认值是1。

（2）一个名为on的boolean类型成员变量表示风扇是否打开，默认值是false。

（3）一个名为radius的double类型成员变量表示风扇的半径，默认值为5。

（4）一个名为color的String类型成员变量表示风扇的颜色，默认值为“蓝色”。

（5）一个创建带默认值的风扇的无参构造方法。

（6）一个创建带指定风扇速度、半径、颜色和是否打开状态的风扇的构造方法。

（7）一个名为print()的方法输出描述风扇的信息。如果风扇是打开的，则输出风扇的速度、半径和颜色。如果风扇没有打开，则输出提示信息“风扇未打开”以及风扇的半径和颜色。方法头如下所示：

public void print()

编写一个测试程序FanTest类，创建两个Fan对象：第一个对象各成员变量使用默认值；将第二个对象设置速度为3、半径为10、颜色为绿色，状态为打开。通过调用它们的print()方法输出这两个对象的信息。

代码如下：

public class FanTest {
    public static void main(String[] args) {
		// TODO Auto-generated method stub
		Fan f1=new Fan();
		Fan f2=new Fan(3,true,10,"绿色");
		f1.print();
		f2.print();
	}
}
class Fan{
	int speed;boolean on;double radius;String color;
	public Fan(){
		speed=1;
		on=false;
		radius=5;
		color="蓝色";	
	}
	public Fan(int speed,boolean on,double radius,String color){
		this.speed=speed;
		this.on=on;
		this.radius=radius;
		this.color=color;
	}
	public void print(){
		if(this.on==false)
		System.out.println("风扇未打开"+" "+"风扇的半径："+radius+" "+"风扇的颜色："+color);
		else
		System.out.println("风扇已打开"+" "+"风扇速度："+speed+" "+"风扇的半径为"+radius+" "+"风扇的颜色为"+color);
	}
}

运行结果：

2. 设计一个复数类Complex。这个类包括：

（1）一个名为realPart的int型成员变量，代表复数的实数部分，默认值为0。

（2）一个名为imaginPart的int型成员变量，代表复数的虚数部分，默认值为0。

（3）一个创建带默认值的复数的构造方法。

（4）一个创建带指定实数部分、虚数部分的复数的构造方法。

（5）一个名为complexAdd的方法将当前复数对象与形参复数对象相加，返回相加后所得的复数值。方法头如下所示：

public Complex complexAdd(Complex c)

（6）一个名为toString方法，把当前复数对象的实部和虚部组合成a + bi的字符串形式，其中a和b分别为实部和虚部数据。方法头如下所示：

public String toString()

编写一个测试类ComplexTest，使用复数类Complex验证两个复数1+2i和3+4i相加产生1个新的复数4+6i。

代码如下：

public class ComplexTest {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Complex c1=new Complex(1,2);
		Complex c2=new Complex(3,4);		
		System.out.print(c1.complexAdd(c2).toString());
	}
}
class Complex{
	int realPart;
	int imaginPart;
	public Complex(){
		realPart=0;
		imaginPart=0;
	}
	public Complex(int realPart,int imaginPart){
		this.realPart=realPart;
		this.imaginPart=imaginPart;
	}
	public Complex complexAdd(Complex c){
		c.realPart+=this.realPart;
		c.imaginPart+=this.imaginPart;
		return c;
	}
	public String toString(){
		int a,b;
		a=realPart;
		b=imaginPart;
		String c=a+"+"+b+"i";
	    return c;		
	}
}

运行结果：