Java期末 简答题(论述题)以及几个编程题(常考)

推荐这个阿里P7大佬的课
https://www.bilibili.com/video/BV19X4y1M7RH/?spm_id_from=333.999.0.0

继承性总结:

请举例简要说明JAVA语言的继承机制?

1Java继承的关键字：extends
2优势:
• 提高了代码的复用性；
• 提高了代码的维护性；
• 建立了类与类之间的关系，这个是多态的前提。
3缺点：1.耦合性太大
2.就是破坏了类的封装性
4特点: 1 java中，继承是单继承
2java在创建一个对象的时候首先会去调用父类的不带参数的默认的构造方法，就是为了创建父类对象
，然后再去调用子类的构造方法。
3子类可以使用父类中的成员变量和方法，然后也可以添加自己的属性和方法。

抽象类和接口的异同:

同: 1接口和抽象类都不可以被实例化
2都拥有需要被实现的抽象方法
异: 1抽象类使用abstract修饰接口使用interface修饰；
2一个类只能继承一个类，但是可以实现多个接口
3接口中方法均为抽象方法；抽象类可以含有抽象方法，也可以不包含抽象方法
4抽象类中可以定义成员变量，而接口中定义的成员变量实际上都是常量
5抽象类中的成员可以是private、default(即不写访问修饰符)、protected、public的，而接口中的成员全都是public的
抽象类：
　　　　1、抽象类使用abstract修饰；
　　　　2、抽象类不能实例化，即不能使用new关键字来实例化对象；
　　　　3、含有抽象方法（使用abstract关键字修饰的方法）的类是抽象类，必须使用abstract关键字修饰；
　　　　4、抽象类可以含有抽象方法，也可以不包含抽象方法，抽象类中可以有具体的方法；
　　　　5、如果一个子类实现了父类（抽象类）的所有抽象方法，那么该子类可以不必是抽象类，否则就是抽象类；
　　　　6、抽象类中的抽象方法只有方法体，没有具体实现；　
　　接口：
　　　1、接口使用interface修饰；
　　　　2、接口不能被实例化；
　　　　3、一个类只能继承一个类，但是可以实现多个接口；
　　　　4、接口中方法均为抽象方法；
　　　　5、接口中不能包含实例域或静态方法（静态方法必须实现，接口中方法是抽象方法，不能实现）；

面向对象的三大特征。

1.封装+
“通过 private、default 、protected、 public 关键字实现属性或方法的封装, 仅对外提供公共访问方式。+
“高内聚，低耦合”4

封装的好处**?

1实现数据项和方法的隐藏
2实现隐藏隔离，允许外部对类做有限的访问,开发者可以自由的改变类的内部实现
3提高了代码的重用性
**

2继承
一通过 extends。
两个好处: +
1.代码重用。了，
2. 通过继承 实现对现实世界更加准确的建模+

3多态: -一个对象变量可以指向多种实际类型对象的现象被称为“多态”
三个必要条件:继承、方法的重写、父类弓|用指向子类对象
多态的好处:
提高了代码的维护性（继承保证）；提高了代码的扩展性
Java中多态的实现方式:接口实现，继承父类进行方法重写，同- -个类中进行方法重载。父类弓|用指向子类对象

栈 :

1.存放局部变量+
2.不可以被多个线程共享。
3.空间连续， 速度快+
4存放于二级缓存中

堆:

1.存放对象。
2.可以被多个 线程共享4
3.空间不连续，速度慢。但是灵活
4 使用的是一级缓存

定义多线程的方式:

Extends Thread←
Implements Runnable←

多线程的状态: 新建就绪状态  运行状态  阻塞状态 死亡

内部类

构造函数与普通函数的区别

1） 格式不同：
　　　　　　构造函数不存在返回类型，函数名与所在类的类名一致；
　　　　　　普通函数有返回类型，函数名可以根据需求进行命名。
　　　　2）调用时期不同
　　　　　　构造函数在类的对象创建时就运行；
　　　　　　普通函数在对象调用时才会执行。
　　　　3）执行次数不同
　　　　　　一个对象创建后，其构造函数只执行一次，就是创建时执行；
　　　　　　一个对象创建后，其普通函数可以执行多次，取决于对象的调用次数。

正则表达式:

Swing基本组件:

Swing布局:

事件处理的三要素:

请举例简要说明JAVA语言使用事件监听器进行事件处理的过程

。
1 首先事件监听器(包含真正处理事件的代码)向事件源(与事件关联的控件，如按钮、滚动
条)注册，
2事件(敲击键盘，或点击鼠标)发生时，事件源向事件监听器发送一-个事件对象
(如果在该事件源上注册了多个事件监听器，则向所有的监听器发送)
3监听器对象随后会根据事件对象内的相应方法响应这个事件
四种实现方式:
自身类作为事件监听器 :
外部类作为事件监听器 :
内部类作为事件监听器:
匿名内部类作为事件监听器
事件添加方法:

2 .添加事件方法

C++ JAVA区别:

不同:

同:
都使用了面向对象的思想(例如封装，继承，多态等)，并且两者具有很好的可重用性。

JAVA语言有哪些特点:

(1)简单的
Java摒弃了C++中容易引发程序错误的一些特性，如指针、结构、枚举以及内存管理等。
Java提供了丰富的类库，可以帮助我们很方便的开发Java程序。
(2)面向对象的
面向对象可以说是Java最重要的特性,所以它支持继承、重载、多态等面向对象的特性。Java
语言的设计是完全面向对象的
(3)健壮的
Java致力于检查程序在编译和运行时的错误。Java自己负责内存管理,
提供了垃圾内存回收机制，有效的避免了C++中最头疼的内存泄漏问题。
(4)安全的
Java的安全性可从两个方面得到保证。一方面，在Java语言里，删除了指针和释放内存等
C++功能，避免了非法内存操作。另一方面，通过Java的安全体系架构来确保Java代码的安全性。
(5)解释的
Java代码是解释执行的，我们使用Java 编译器将Java 代码编译成字节码，这是一种中间代
码，然后由Java 解释器解释执行。而C++程序是编译执行的，
(6)与平台无关的
其源代码被编译成1种结构中立的中间文件格式。只要有Java 运行系统的机器都能执行这种中间代码。
Java源程序被编译成一种与机器无关的字节码格式，在Java虚拟机上运行。
(7) 多线程的
Java语言的一个重要特性就是在语言级支持多线程的程序设计。
(8)动态的
Java的动态特性是其面向对象设计方法的扩展。它允许程序动态地装入运行过程中所需要的类。

C语言和JAVA区别:

不同:
1 C语言是面向过程的语言，执行比JAVA效率高 Java是面向对象的语言
2 C语言不能跨平台；java可以跨平台直接移植
3 c语言是int short long char float double 还有一些特殊类型 结构体，指针，联合体等，数组，字符串 ；
java 是byte int short long float double char boolean ，而且c语言的基本类型的位数和操作系统和机器相关，而java 是固定的；
4 C语言以头文件来阻止文件 JAVA以类来阻止文件
5 Java采用Unicode字符集，C语言通常采用的是ASCII字符集。
6 C语言的变量可以不进行初始化，但Java的变量要进行初始化。
同:
1 编程语言都是由语法和相应的程序库所构成，Java有自身的类库，C语言则有标准库
2 Java可以算是从C++发展而来的bai，因此Java与C语言的语法比较类似

实例变量和类变量的区别

类变量和实例变量的区别是什么？
类变量也叫静态变量，也就是在变量前加了static 的变量；
实例变量也叫对象变量，即没加static 的变量；
区别在于：
类变量和实例变量的区别在于：类变量是所有对象共有，其中一个对象将它值改变，其他对象得到的就是改变后的结果；而实例变量则属对象私有，某一个对象将其值改变，不影响其他对象；

实例方法和类方法的区别

区别：
1、类方法是属于整个类，而不属于某个对象。
2、类方法只能访问类成员变量，不能访问实例变量，而实例方法可以访问类成员变量和实例变量。
3、类方法的调用可以通过类名.类方法和对象.类方法，而实例方法只能通过对象.实例方法访问。
4、类方法只能访问类方法，而实例方法可以访问类方法和实例方法。
5、类方法不能被覆盖，实例方法可以被覆盖。
子类对象的构造过程:
1.加载父类，为父类的静态变量分配内存。
2.加载子类，为子类的静态变量分配内存。
3.执行父类静态变量的赋值运算和父类的静态初始化块。
4.执行子类静态变量的赋值运算和子类的静态初始化块。
//静态变量和静态初始化块的执行顺序是按代码中静态变量和初始化块的先后顺序来执行
5.创建父类对象，为父类非静态变量分配内存。
6.创建子类对象，为子类非静态变量分配内存。
7.执行父类非静态变量的赋值运算。
8.执行父类的构造方法。
9.执行子类非静态变量的赋值运算。
10.执行子类的构造方法。

面向对象和面向过程的区别:

面向过程：
当需要实现一个功能的时候，每一个步骤我们都需要自己去做，处理实现功能的每一个细节。
面向对象：
当需要实现一个功能的时候，我们不需要自己去做，可以直接找一个已经具有该功能的东西，来帮我解决问题。
面向对象三大特征：封装、继承、多态。
　面向过程
　　优点：性能比面向对象高
　面向对象
　　优点：易维护、易复用、易扩展。

数组与ArrayList区别:

请举例说明string类与StringBuffer类的区别:

String中的方法都是返回一个新的字符串，而没有改变原来的字符串; String 类重写了Object
的equals方法，String类能用 “十”连接
StringBuffer中的方法都是能改变原字符串的值; StringBuffer 类没有重写了Object 的equals
方法，StringBuffer 类不能用“十”连接
请举例说明重载和重写的区别:
重写:子类可以重新实现父类的某些方法，并具有自己的特征。
重载:方法重载使得在类中可以存在方法名相同的多个方法，
但方法的原型不能完全相同，方法的原型包括方法名和方法参数类型。
区别:方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，
而后者实现的是运行时的多态性。重载发生在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）则视为重载；
重写发生在子类与父类之间，重写要求子类被重写方法与父类被重写方法有相同的参数列表，有兼容的返回类型，
比父类被重写方法更好访问，不能比父类被重写方法声明更多的异常。重载对返回类型没有特殊的要求，不能根据返回类型进行区分。

Equal 和 == 区别:

equal() :比较的是对象的内容
== :如果比较的是基本类型，则比较的是值；如果比较的是引用类型，则比较是对象的引用地址

异常的分类?它们的区别是什么?

Error:称为错误，由Java虚拟机生成并抛出，包括动态连接失败、虚拟机错误等，程序对其不作处理。
Exception:所以异常类的父类，其子类对应了各种各样可能出现的异常事件，-般需要用户显式的声明或捕获。
Runtime Exception: -类特殊的异常，如被0除、数组下标超范围等，其产生比较频繁，处
理麻烦,如果显式的声明或捕获将会对程序的可读性和运行效率影响很大。因此由系统自动
检测并将它们交给缺省的异常处理程序。

字节流字符流区别:

流: 在程序中所有的数据都是以流的方式进行传输或保存的，程序需要数据的时候要使用输入流读取数据，而当程序需要将一些数据保存起来的时候，就要使用输出流完成。
区别:字节流在操作的时候本身是不会用到缓冲区（内存）的，是与文件本身直接操作的，而字符流在操作的时候是使用到缓冲区的
　　字节流在操作文件时，即使不关闭资源（close方法），文件也能输出，但是如果字符流不使用close方法的话，则不会输出任何内容，说明字符流用的是缓冲区，并且可以使用flush方法强制进行刷新缓冲区，这时才能在不close的情况下输出内容

二分查找:

`public static int biSearch(int []array,int a) {
    int lo=0;
    int hi=array.length-1;
    int mid;
    while(lo<=hi){
        mid=(lo+hi)/2;
        if(array[mid]==a){
            return mid+1;
        }else if(array[mid]<a){
            lo=mid+1;
        }else{
            hi=mid-1;
        }
    }
    return -1;}

选择排序:

//选择排序的优化
for(int i = 0; i < arr.length - 1; i++) {// 做第i趟排序
int k = i;
for(int j = k + 1; j < arr.length; j++){// 选最小的记录
if(arr[j] < arr[k]){
k = j; //记下目前找到的最小值所在的位置
}
}
//在内层循环结束，也就是找到本轮循环的最小的数以后，再进行交换
if(i != k){ //交换a[i]和a[k]
int temp = arr[i];
arr[i] = arr[k];
arr[k] = temp;
}
}

冒泡排序:

for(int i=0;i<arr.length-1;i++){//外层循环控制排序趟数
　　　　　　for(int j=0;j<arr.length-1-i;j++){//内层循环控制每一趟排序多少次
　　　　　　　　if(arr[j]>arr[j+1]){
　　　　　　　　　　int temp=arr[j];
　　　　　　　　　　arr[j]=arr[j+1];
　　　　　　　　　　arr[j+1]=temp;
　　　　　　　　}
　　　　　　}
　　　　} 

数据库链接:

 import java.sql.*;
public class TestConnectionSQL {

	public static void main(String[] args) throws SQLException {
		Connection connection=null;
		Statement statement;
		ResultSet rs;
		
		try {
			Class.forName("com.mysql.jdbc.Driver");
		} catch (Exception e) {
			System.out.println(e);
		}
		String url="jdbc:mysql://localhost:3306/student?"+"useSSL=false&characterEncoding=utf-8";
		String user="root";
		String password="root";
		try {
			connection=DriverManager.getConnection(url,user,password);
		}catch (Exception e) {
			// TODO: handle exception
		System.out.println(e);
		}
		try {
			statement=(Statement) connection.createStatement();
			rs=((java.sql.Statement) statement).executeQuery("select * from grade where c_grade>60&&java_grade>60");
			while(rs.next()) {
				String name=rs.getString(2);
				String stu_idString=rs.getString(5);
				System.out.println("所有成绩大于60的 学生学号 和姓名为: "+stu_idString+" "+name);
			
			}
			connection.close();
		}catch (Exception e) {
			// TODO: handle exception
			System.out.println(e);
		}
	}
}

手写计算器:

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JTextField;
import javax.swing.text.View;
public class ComputerLisener implements ActionListener {
   WindowView view;
   String fuhao;
	public void setView(WindowView windowView) {
		 this.view=windowView;
	}
	public void setFuHao(String fuhao) {
		this.fuhao=fuhao;
		
	}
	@Override
	public void actionPerformed(ActionEvent e) {
		try{
			Double num1=Double.valueOf(view.textInput1.getText());
		Double num2=Double.valueOf(view.textInput2.getText());
		Double result = null;
		Boolean isShow=true;
		
			if(fuhao.equals("+")) {
				result=num1+num2;
			}
			else if(fuhao=="-") {
				result=num1-num2;
			}else if(fuhao=="*") {
				result=num1*num2;
			}else if(fuhao=="/") {
				result=num1/num2;
			}
			else{isShow=false;}
			
			if(isShow) {
				view.textShow.append(num1+""+fuhao+""+num2+" = "+result);
			}
		}catch (Exception e1) {
			view.textShow.append("请输入数字");
		}			}	}
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
public class OperaterLIstener implements ItemListener {
	WindowView view;
	public void setView(WindowView view) {
		this.view = view;
	}
	@Override
	public void itemStateChanged(ItemEvent e) {
		String fuhao=view.choiceBox.getSelectedItem().toString();
		view.computer.setFuHao(fuhao);
	}}
public class CaculatorDemo {

	public static void main(String[] args) {
		new WindowView();
	}
}

import java.awt.FlowLayout;
import java.util.Arrays;

import javax.naming.InitialContext;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;

public class WindowView extends JFrame {
  public OperaterLIstener operater=new OperaterLIstener();
  public ComputerLisener computer=new ComputerLisener();
  public JTextField textInput1;
  public JTextField textInput2;
  public JTextArea textShow;
  public JButton button;
  public JComboBox<String> choiceBox=new JComboBox<String>();
 
	public WindowView(){
		setBounds(250,200,600,500);
		setTitle("简单计算器");
	 setLayout(new FlowLayout());
	 setVisible(true);
	 setDefaultCloseOperation(EXIT_ON_CLOSE);
	 textInput1=new JTextField(10);
	 textInput2=new JTextField(10);
	 textShow=new JTextArea(5,10);
	 textShow.setEditable(false);
	 button=new JButton("计算");
	 choiceBox.addItem("请下拉选择符号");   //必须有 否则不选一下不能获取符号
	 String[] a= {"+","-","*","/"};
	 for (int i = 0; i < a.length; i++) {
         choiceBox.addItem(a[i]);		
	}
	 operater.setView(this);
	 computer.setView(this);
	 choiceBox.addItemListener(operater);
	 button.addActionListener(computer);
	 add(textInput1);
	 add(choiceBox);
	 add(textInput2);
	 add(button);
	 add(new JScrollPane(textShow));
	}}

定义一个长方形类，该类具有长和宽两种属性，并具有相应的构造方法、属性访问方法 算周长和面积的方法，要求输出长是5宽是4的长方形的面积和周长。

public class Rectangle {
private double length;/长
private double width;/宽
public Rectangle (){  }
public Rectangle (double length, double width){
this.length=length;
this.width=width;
} 
public void setLength(double Iength){
length=length;}
public void setWidth(double width){
width=width;}
public double getLength(){
return length;}
public double getWidth(){
return width;}
public double area(double i, double j){ 
return (length*width);}
public double permcter (double i, double j){
return (length+width)*2);}
public static void main(String []args){
System.out.prntn("长为5，宽为4的长方形的周长与面积: ");
Rectangle Rectangle =new Rectangle (5,4);
System.out.println("周长(5,4)=" +Rectangle.permcter(5,4));
System.out.println("面积(5,4)="+Rectangle.area(5,4));
}}

继承新增属性

1!+2!+3!+…+n!

public class OneDemo {
public static void main(String[] args) {
    sumMethod();
   sortMethod();
   binaryMethod();
   changeMethod();
}
public static void sumMethod() {
Scanner scanner=new Scanner(System.in);
	System.out.println("请输入n值");
	long sum=0,temp=1;
	int n=scanner.nextInt();
	for(int i=1;i<=n;i++) {
		temp*=i;
		sum+=temp;
	}
	System.out.println(" 1!+2!+3!+…+n!="+sum);
}

产生100个随机数并使用冒泡排序和选择排序对这些数进行排序

public static void sortMethod() {
public static void main(String []args){
	int[] numArray=new int[100];
	for(int i=0;i<100;i++) {
		numArray[i]=(int) (Math.random()*1000);
	}
	System.out.println("选择排序后为");
     selectSort(numArray);	
 	System.out.println("");
 	int[] numArray2=new int[100];
	for(int i=0;i<100;i++) {
		numArray2[i]=(int) (Math.random()*1000);
	}
     System.out.println("冒泡排序后为");
     bubbleSort(numArray2);
     System.out.println("");
}
public static void selectSort(int[] arr) {
	
	for(int i=0;i<arr.length-1;i++) {
		for(int j=i+1;j<arr.length;j++) {
			if(arr[i]>arr[j]) {
            int temp=arr[i];
            arr[i]=arr[j];
            arr[j]=temp;
			}
		}
	}
	printMethod(arr);
	
}

public static void bubbleSort(int[] arr) {
	for(int i=0;i<arr.length;i++) {
		for(int j=0;j<arr.length-i-1;j++){
			if(arr[j]>arr[j+1]) {
				int temp=arr[j];
				arr[j]=arr[j+1];
				arr[j+1]=temp;
			}
		}
	}		
	printMethod(arr);
	
}
public static void printMethod(int[] arr) {
	
	for(int i=0;i<arr.length;i++) {
		System.out.print(arr[i]+" ");
	}
}}

利用二分查找算法对一个有序数列进行查找

public static void binaryMethod() {
	int[] arr= {1,2,3,4,5,6,7,8,99};
	System.out.println("请输入二分查找的数    n");
	Scanner scanner=new Scanner(System.in);
	int n=scanner.nextInt();
	int x=Arrays.binarySearch(arr,n);
	if(x<0) {
		System.out.println(n+"未找到");
	}else {
		System.out.println(n+"在第"+(x+1)+"个位置");
	}
}
不同进制之间的转换
public static void changeMethod() {
	System.out.println("请依次输入  要转换的进制m 转换后的进制n 转换前的值numBefore");
	Scanner scanner=new Scanner(System.in);
	int m=scanner.nextInt();
	int n=scanner.nextInt();

	if(m==10) {
		int numBefore=scanner.nextInt();
		String numAfter=Integer.toString(numBefore,n);
		System.out.println(m+"进制 "+numBefore+" 转为 "+n+"进制后为 "+numAfter);
	}else {
		String numBefore=scanner.next();
		int temp=Integer.parseInt(numBefore,m);
		String numAfter=Integer.toString(temp,n);
		System.out.println(m+"进制 "+numBefore+" 转为 "+n+"进制后为 "+numAfter);
	}
}

编写 Java 程序用于显示人的姓名和年龄。定义一个人类Person。 该类中应该有两个私有属性： 姓名 （name） 和年龄 （age） 。定义构造方法用来初始化数据成员。再定义显示（display()） 方法将姓名和年龄打印出来。在 main 方法中创建人类的实例然后将信息显示。

public class Person {

	private String name;
	private int age;
	public Person(String name,int age) {
		this.age=age;
		this.name=name;
	}
	
	public static void display(Person person) {
		System.out.println("  姓名:"+person.name+"   年龄:"+person.age);
	}
	public static void main(String[] args) {
		Person person=new Person("CaesarChang", 20);
		display(person);
	}}

构造方法与重载：定义一个网络用户类，要处理的信息有用户 ID、用户密码、 email 地址。在建立类的实例时把以上三个信息都作为构造函数的参数输入， 其中用户 ID和 用户密码时必须缺省时 email地址是用户 ID 加上字符串"@gameschool.com".

public class NetUser {
	public Integer id;
	public String email;
	public String password;
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public NetUser(Integer id, String email, String password) {
		super();
		this.id = id;
		this.email = email;
		this.password = password;
		if(id.equals("")||password.equals("")) {
			this.email=Integer.toString(id)+"@gmaeschool.com";
		}
	}
	public String toString() {
		return "NetUser [id=" + id + ", email=" + email + ", password=" + password + "]";
	}
	public static void main(String[] args) {
		NetUser netUser=new NetUser(1," root121toor@gmail.com", "123");
		System.out.println(netUser);
	}}

定义一个表示学生信息的类 Student，要求如下： （1）类 Student 的属性如下：sNO 表示学号； sName 表示姓名； sSex 表示性别； sAge 表示年龄；sJava：表示 Java 课程成绩。 （2）类 Student 带参数的构造方法：在构造方法中通过形参完成对成员变量的赋值操作。 （3）类 Student 的方法成员：etNo（）：获得学号；getName（）：获得姓名；getSex（）：获得性别；getAge（）获得年龄；getJava（）：获得 Java 课程成绩 ，创建五个该类的对象，输出每个学生的信息，计算并输出这五个学生 Java 语言成绩的平均值，以及计算并输出他们 Java 语言成绩的最大值和最小值。

public class Student {
	public int sNO;
	public String sName;
	public String gender;
	public int age;
	public Double sJava;

	public int getsNO() {
		return sNO;
	}
	public Student(int sNO, String sName, String gender, int age, double sJava) {
		this.sNO = sNO;
		this.sName = sName;
		this.gender = gender;
		this.age = age;
		this.sJava =sJava;
	}
	public String getsName() {
		return sName;
	}
	public void setsName(String sName) {
		this.sName = sName;
	}
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public Double getsJava() {
		return sJava;
	}
	public void setsJava(Double sJava) {
		this.sJava = sJava;
	}
	public void setsNO(int sNO) {
		this.sNO = sNO;
	}
	public String toString() {
		return "Student [sNO=" + sNO + ", sName=" + sName + ", gender=" + gender + ", age=" + age + ", sJava=" + sJava
				+ "]";
	}
	
	public static void ord(Double[] score) { 
		for(int i=0;i<score.length;i++) {
			for(int j=0;j<score.length-i-1;j++) {
				if(score[j]>score[j+1]) {
					Double temp=score[j+1];
					score[j+1]=score[j];
					score[j]=temp;
				}
			}
		}
		System.out.println("极大值为 "+score[4]);
		System.out.println("极小值为 "+score[0]);	
	}
	public static void aver(Double[] score) {
		double sum=0;
		for(int i=0;i<score.length;i++) {
		 sum=sum+score[i];
		}
		double average=sum/5;
		System.out.println("平均值为"+average);
	}
	public static void main(String[] args) {
		Double[] score = new Double[5];
		Student[] stu = new Student[5];
		 stu[0]=new Student(1,"aa","男",21,99.9);
		 stu[1]=new Student(2,"bb","男",23,90.9);
		 stu[2]=new Student(3,"cc","女",29,91.9);
		 stu[3]=new Student(4,"dd","未知",19,94.9);
		 stu[4]=new Student(5,"ee","男",18,95.9);
		for(int i=0;i<5;i++) {
		  score[i]=(Double) stu[i].getsJava();
		}
		for(int i=0;i<5;i++) {
			System.out.println(stu[i]);
		}
		ord(score);
		aver(score);
		}}

编写程序,求柱体的体积: （1）、为柱体的底面设计一个接口Geometry，包含计算面积的方法getArea(); （2）、为柱体设计类pillar，要求： a)有两个成员变量，底面和高度。底面是任何可以计算面积的几何形状。 b)实现构造方法，对成员变量赋值。 c)包含成员方法，计算柱体pillar的体积。 （3）、编写测试类圆形类、矩形类实现Geometry接口，编写测试类Test，分别用圆形、矩形作为柱体的底面，并计算其体积。

public interface Geometry {
 Double getArea(); 
}
class Round implements Geometry{
	public double R;

	public void setR(double r) {
		R = r;
	}

	public Double getArea() {
		return Math.PI*R*R;
	}
}
class Rectangle implements Geometry{
	public double length;
	public double width;
	
	public Rectangle(double length, double width) {
		super();
		this.length = length;
		this.width = width;
	}

	public Double getArea() {
		
		return width*length;
	}
}	

import java.util.Scanner;
class Pillar{
	public Geometry geometry;
	public double height;
	public void setGeometry(Geometry geometry) {
		this.geometry = geometry;
	}
	public void setHeight(double height) {
		this.height = height;
	}
	public Pillar(Geometry geometry, double height) {
		this.geometry = geometry;
		this.height = height;
	}
	
	public  double V(){
		return this.geometry.getArea()*height;
	}	
}
public class Test  {
	public static void main(String[] args) {
		Scanner scanner=new Scanner(System.in);
		Round round=new Round();
		System.out.println("请输入圆的半径");
		double r=scanner.nextDouble();
		round.setR(r);
		System.out.println("请输入高");
		double height=scanner.nextDouble();
		Pillar pillar=new Pillar(round, height);
		System.out.println("地面为圆的时候体积为 "+pillar.V());
		System.out.println("请输入长");
		double length=scanner.nextDouble();
		System.out.println("请输入宽");
		double width=scanner.nextDouble();
		Rectangle rectangle=new Rectangle(length,width);
		System.out.println("请输入高度");
		double height2=scanner.nextDouble();
		Pillar pillar2=new Pillar(rectangle, height2);
		System.out.println("地面为长方形的时候体积为 "+pillar2.V());

	}}

、编写一个Java应用程序，该程序包括3个类：Animal、Monkey类和测试类。 （1）Animal有name（名字）、age(年龄)两个属性。有个带参构造方法，并且有个speak()抽象方法 （2）Monkey是Animal的子类，显示调用父类的带构造，在Monkey类中重写父类的方法speak(),在speak方法中输出“别说话！”的信息。在Monkey类中新增方法void think()，在think方法中输出“认真思考！”。（3）测试类中测试程序

public class Test {
	public static void main(String[] args) {
		Monkey monkey=new Monkey(22, "大圣");
		monkey.speak();
		monkey.think();
	}}
	 abstract class Animal {
		  public Integer age;
		  public String name;
		  public Animal(Integer age,String name) {
			  this.age=age;
			  this.name=name;
		  }
		  public abstract void speak();
		}
	class Monkey extends Animal{
			public Monkey(Integer age, String name) {
				super(age, name);
			}
			public void think() {
				System.out.println("认真思考");
			}
			public void speak() {
				System.out.println("别说话");
			}
		}

、编写程序，请用户输入一个 “QQ号码”，定义正则表达式，验证这个 QQ 号码是否符合以下要求： (1) 5 – 12 位长度；(2) 全部是数字；(3) 首位不能是 0

import java.util.Scanner;
public class LoginTest {
	public static void main(String[] args) {
		String regexString;
		String input;
		Scanner scanner=new Scanner(System.in);
		System.out.println("请输入QQ号码");
		input=scanner.nextLine();
		regexString="[1-9][0-9]{4,11}";
		if(input.matches(regexString)) {
			System.out.println("输入成功");
		}else {
			System.out.println("格式错误 请重新输入");
		}
	}
}

编写程序，请用户输入一个 “手机号码”，定义正则表达式，验证这个手机号码是否符合以下要求： (1)必须以数字 1 开头；(2)第二位是：3,5,7,8 中的一位；(3)剩下的全部是数字

public class PhoneNumberTest {

	
	public static void main(String[] args) {
		String regexString;
		String input;
		Scanner scanner=new Scanner(System.in);
		System.out.println("请输入手机号码");
		input=scanner.nextLine();
		regexString="[1][3|5|7|8][0-9]{9}";
		if(input.matches(regexString)) {
			System.out.println("输入成功");
		}else {
			System.out.println("格式错误 请重新输入");
		}}}
利用接口实现计算器
//（1）定义一个接口Compute含有一个方法int computer(int n, int m)。 
interface Compute{
    int computer(int n, int m);
}
//（2）设计四个类分别实现此接口，完成加减乘除运算。 
// 加法
class AddImpl implements Compute{
    public int computer(int n, int m)
    {
        return n + m;
    }
}
// 减法
class SubImpl implements Compute{
    public int computer(int n, int m)
    {
        return n - m;
    }
}
// 乘法
class MulImpl implements Compute{
    public int computer(int n, int m)
    {
        return n * m;
    }
}
// 除法--->需注意除法的分母不能为空
class DivImpl implements Compute{
    public int computer(int n, int m)
    {
        if(m == 0)
        {
            System.out.println("分母为空！！！");
            return 0;
        }
        else
        {
            return n / m;
        }
    }
}
/**

（3）设计一个类UseCompute， 类中含有方法：public void useCom(Compute com, int one, int two)， 此方法能够用传递过来的对象调用computer方法完成运算，并输出运算的结果。

 */
class UseCompute{
    public void useCom(Compute com, int one, int two)
    {
        System.out.println(com.computer(one, two));
    }
}
//（4）设计一个主类Test，调用UseCompute中的方法useCom来完成加减乘除运算。
public class Test{
    public static void main(String[] args){
        UseCompute uc = new UseCompute();
        uc.useCom(new AddImpl(), 4, 2);
        uc.useCom(new SubImpl(), 4, 2);
        uc.useCom(new MulImpl(), 4, 2);
        uc.useCom(new DivImpl(), 4, 2);
        uc.useCom(new DivImpl(), 4, 0);
    }
}

学生成绩等级划分:

import java.util.Scanner;
public class test {
public static void main(String[] args) {
Scanner x = new Scanner(System.in);
System.out.println("请输入成绩");
int a=x.nextInt();
int n=a/10; //百分bai制转换为等第
switch(n){
case 10: //表示如果n=10，也就是一百du分，zhi输出A
case 9:
System.out.println("A");
break;
case 8:
System.out.println("B");
break;
case 7:
System.out.println("C");
break;
case 6:
System.out.println("D");
break;
case 5:
case 4:
case 3:
case 2:
case 1:
case 0:
System.out.println("FAIL"); //低于六十分的输出不及格dao FAIL
break;
default:System.out.println(" 请输入一个正确的成绩"); //输入的不是百分制，报错
}
}
}