jjjjjjjjavaaaaaaaaa

程序员文章站 2022-03-20 23:03:35

四、编程题复习1、登录(GUI界面):通过JDBC访问数据库查询表方式登录也需要掌握。Package student；import java.awt.FlowLayout;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import javax.swing.JButton;import javax.swing.JFrame;import javax.swing.JLabel;import java...

``四、编程题复习

1、登录(GUI界面):通过JDBC访问数据库查询表方式登录也需要掌握。
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JPasswordField;
import javax.swing.JTextField;
import javax.swing.SwingUtilities;

public class example01 {
public static void main(String[] args)
{
SwingUtilities.invokeLater(example01::createGUI);
}
public static void createGUI()
{
JFrame frame = new JFrame(“登录系统”);
frame.setBounds(300,300,400,300);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//设置布局格式
frame.setLayout(new FlowLayout());

//设置组件
JLabel labeluser = new JLabel(“用户名”);
JLabel labelpwd = new JLabel(“密码”);
JTextField userfield = new JTextField(10);
JPasswordField pwdfield = new JPasswordField(10);
//添加组件
frame.add(labeluser);
frame.add(userfield);
frame.add(labelpwd);
frame.add(pwdfield);

JPanel panel = new JPanel();
panel.setLayout(new FlowLayout());
JButton btn1 = new JButton(“登录”);
JButton btn2 = new JButton(“退出”);
panel.add(btn1);
panel.add(btn2);
frame.add(panel);
//事件监听
btn1.addActionListener(new ActionListener()
{

@Override
public void actionPerformed(ActionEvent e)
{
String user = userfield.getText().trim();
String pwd = new String(pwdfield.getPassword());
if(user.equals(“root”) && pwd.equals(“root”))
{
JOptionPane.showMessageDialog(frame,“登录成功”);
}
else
{
JOptionPane.showMessageDialog(frame,“用户名或密码错误”);
}
}
});
btn2.addActionListener(new ActionListener()
{

@Override
public void actionPerformed(ActionEvent e)
{
System.exit(0);
}

});
frame.setVisible(true);
}
}
通过JDBC访问数据库登录
import java.awt.FlowLayout;
import java.awt.HeadlessException;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JPasswordField;
import javax.swing.JTextField;
import javax.swing.SwingUtilities;
import com.mysql.jdbc.ResultSet;
import com.mysql.jdbc.Statement;

public class example02
{
static String user;
static String pwd;

public static void main(String[] args) throws ClassNotFoundException
{
SwingUtilities.invokeLater(example02::createGUI);
}

public static void createGUI()
{
JFrame frame = new JFrame(“登录系统”);
frame.setBounds(300,300,400,300);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//设置布局格式
frame.setLayout(new FlowLayout());

@Override
public void actionPerformed(ActionEvent e)
{
user = userfield.getText().trim();
pwd = new String(pwdfield.getPassword());
try {
if(connectionSQL())
{
JOptionPane.showMessageDialog(frame,“登录成功”);
System.exit(0);
}
else
{
JOptionPane.showMessageDialog(frame,“用户名或密码错误”);
System.exit(0);
}
} catch (HeadlessException | ClassNotFoundException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
}
});
btn2.addActionListener(new ActionListener()
{

@Override
public void actionPerformed(ActionEvent e)
{
System.exit(0);
}

});
frame.setVisible(true);
}

public static boolean connectionSQL() throws ClassNotFoundException
{
Class.forName(“com.mysql.jdbc.Driver”);
String url = “jdbc:mysql://localhost:3306/”;
String user_1 = “root”;
String pwd_1 = “root”;
boolean flag = false;
try {
//创建数据库
Connection conn = (Connection)DriverManager.getConnection(url,user_1,pwd_1);
Statement stat = (Statement) conn.createStatement();
stat.executeUpdate(“create database student charset utf8”);
//打开新建的数据库
stat.close();
conn.close();
url = “jdbc:mysql://localhost:3306/student?useUnicode=true&characterEncoding=utf-8”;
conn = DriverManager.getConnection(url,user_1,pwd_1);
stat = (Statement) conn.createStatement();
//创建表
String createtable = “create table stu_user(id varchar(10),pwd varchar(10))charset utf8”;
stat.execute(createtable);
//插入数据
String user1 = “insert into stu_user values(‘root’,‘root’)”;
String user2 = “insert into stu_user values(‘root’,‘123’)”;
String user3 = “insert into stu_user values(‘admin’,‘123’)”;
stat.executeUpdate(user1);
stat.executeUpdate(user2);
stat.executeUpdate(user3);
//查询并判断
ResultSet rs = (ResultSet)stat.executeQuery(“select * from stu_user”);

while(rs.next())
{
String stu_user = rs.getString(“id”);
String stu_pwd = rs.getString(“pwd”);
if(user.equals(stu_user) && pwd.equals(stu_pwd))
{
flag = true;
break;
}
}
rs.close();
stat.close();
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return flag;
}
}
2、猜数游戏(GUI界面)。
import javax.swing.;
import java.awt.;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class example03
{
static int source;
public static void main(String[] args)
{
SwingUtilities.invokeLater(() -> createShowGUI());
}
public static void createShowGUI() {
//设置*容器
JFrame f = new JFrame();
f.setTitle(“猜数游戏”);
f.setSize(250, 180);
f.setLocationRelativeTo(null);
f.setVisible(true);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setLayout(new FlowLayout());
//设置组件
JButton sourceNumber = new JButton(“产生一个100以内的随机数”);
JButton btn = new JButton(“确定”);
JLabel showMessage = new JLabel(“输入您猜的数：”);
showMessage.setOpaque(true);
showMessage.setBackground(Color.pink);
JTextField guessNumber = new JTextField(10);

f.add(sourceNumber);
f.add(showMessage);
f.add(guessNumber);
f.add(btn);
btn.setEnabled(false);

sourceNumber.addActionListener(new ActionListener()
{
@Override
public void actionPerformed(ActionEvent e)
{
source = (int) (Math.random()*100) + 1;
//设置产生键可点击
sourceNumber.setEnabled(false);
//设置确定键不可选中
btn.setEnabled(true);
}
});

btn.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
String guessString = guessNumber.getText().trim();

String regex = “\d+”;
if (!guessString.matches(regex)) {
JOptionPane.showMessageDialog(f, “请输入数字”);
guessNumber.setText("");
guessNumber.requestFocus();
return;
}
int guess = Integer.parseInt(guessString);
if (guess > source) {
guessNumber.setText("");
guessNumber.requestFocus();
showMessage.setText(“猜得大了”);
} else if (guess < source) {
guessNumber.setText("");
guessNumber.requestFocus();
showMessage.setText(“猜得小了”);
} else {
showMessage.setText(“恭喜您猜对了”);
}
}
});
}
}

3、编写一个GUI应用程序，要求如下：
1）在窗口的最上方放置一个JLabel标签，标签中默认的文本是“此处显示鼠标左键点击的坐标”
2）为JFrame窗口添加一个鼠标事件，当鼠标左键点击窗口时，鼠标的坐标在JLabel标签中显示。
import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;

public class example04 {

public static void main(String[] args) {
// TODO Auto-generated method stub
SwingUtilities.invokeLater(example04::createGUI);
}
public static void createGUI()
{
JFrame f = new JFrame();
f.setBounds(200,200,300,260);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
f.setLayout(new FlowLayout());

JPanel panel = new JPanel();
JLabel label = new JLabel(“此处显示鼠标左键点击的坐标”);
label.setOpaque(true);
label.setBackground(Color.pink);
panel.add(label);
f.add(panel);

f.addMouseListener(new MouseListener(){
@Override
public void mouseClicked(MouseEvent e)
{
if(e.getButton() == MouseEvent.BUTTON1)
{
label.setText("("+e.getX()+","+e.getY()+")");
}
}
@Override
public void mousePressed(MouseEvent e) {
}
@Override
public void mouseReleased(MouseEvent e) {
}

@Override
public void mouseEntered(MouseEvent e) {
}
@Override
public void mouseExited(MouseEvent e) {
}

});
}
}
5、编程题：定义一个Student类，该类包括姓名和年龄两个成员变量，定义一个带有姓名和年龄两个参数的构造方法，重写Object类的toString()方法，其返回值为姓名及年龄字符串，在该类中增加main方法，创建ArrayList集合对象，在集合对象中添加4个学生类Student的对象元素如下：
Student(“张三”,19)
Student(“李四”,22)
Student(“王五”,20)
Student(“陈六”,21)
将学生对象按元素添加到集合的的顺序遍历输出，要求使用泛型，并会使用3种遍历方式输出。

import java.util.ArrayList;
import java.util.Iterator;
public class Student_ArrayList {
private String name;
private int age;
Student_ArrayList(String name, int age) {
this.name = name;
this.age = age;
}
public String toString() {
return name+","+age;
}

public static void main(String[] args) {
ArrayList<Student_ArrayList> al=new ArrayList<Student_ArrayList>();
Student_ArrayList student1=new Student_ArrayList(“张三”,19);
Student_ArrayList student2=new Student_ArrayList(“李四”,22);
Student_ArrayList student3=new Student_ArrayList(“王五”,20);
Student_ArrayList student4=new Student_ArrayList(“陈六”,21);
al.add(student1);
al.add(student2);
al.add(student3);
al.add(student4);
//第一种遍历输出方式
Iterator<Student_ArrayList> it=al.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
System.out.println("**************");

/第二种遍历输出方式
for(Object o:al) {
System.out.println(o);
}
System.out.println("**************");

//第三种遍历方式
al.forEach( o -> System.out.println(o));
}
}

6、编写程序，将Person对象存储到HashSet集合中，Person对象具有age和name两个成员变量，若Person对象的成员变量都相同，则认为是同一对象，要求保证对象的唯一性，使用泛型，并会使用3种遍历方式输出。Person对象如下：
Person(“蔡依林”, 20);
Person(“关之琳”, 31);
Person(“王祖贤”, 28);
Person(“林青霞”, 27);
Person(“林青霞”, 29);
Person(“范冰冰”, 25);

package student;

import java.util.HashSet;
import java.util.Iterator;

public class demo1 {

public static void main(String[] args) {
// TODO Auto-generated method stub
HashSet hs = new HashSet();

hs.add(new Person(“蔡依林”,20));
hs.add(new Person(“关之琳”,31));
hs.add(new Person(“王祖贤”,28));
hs.add(new Person(“林青霞”,27));
hs.add(new Person(“林青霞”,29));
hs.add(new Person(“范冰冰”,25));

遍历方法1
// Iterator it = hs.iterator();
// System.out.println(“开始输出”);
// while(it.hasNext()) {
// Person pt = (Person) it.next();
// System.out.println(pt.name+":"+pt.age);
// }
// System.out.println(“输出结束”);

遍历方法2
// System.out.println(“开始遍历”);
// for (Person p : hs) {
// System.out.println(p.name+":"+p.age);
// }
// System.out.println(“结束遍历”);

// 遍历方法3
System.out.println(“开始遍历”);
hs.forEach(s->System.out.println(s.name+":"+s.age));
System.out.println(“结束遍历”);
}

}

class Person {
String name;
int age;
public Person() {

}

public Person(String name,int age) {
this.name = name;
this.age = age;
}

@Override
public String toString() {
return “姓名:”+ this.name + “年龄:” + this.age;
}

@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}

@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}

}
7、编写程序，将Person对象存储到TreeSet集合中，Person对象具有age和name两个成员变量，若Person对象的成员变量都相同，则认为是同一对象，要求按年龄排序，保证对象的有序和唯一性，使用泛型，并会使用3种遍历方式输出。Person对象如下：
Person(“linqingxia”, 27);
Person(“zhangguorong”, 29);
Person(“wanglihong”, 23);
Person(“linqingxia”, 27);
Person(“liushishi”, 22);
Person(“wuqilong”, 40);
Person(“gaoyuanyuan”, 22);

package student;

import java.util.Iterator;
import java.util.TreeSet;

public class demo1 {

public static void main(String[] args) {
// TODO Auto-generated method stub
TreeSet ts = new TreeSet();

ts.add(new Person1(“林青霞”,27));
ts.add(new Person1(“张国荣”,29));
ts.add(new Person1(“王力宏”,23));
ts.add(new Person1(“林青霞”,27));
ts.add(new Person1(“刘诗诗”,22));
ts.add(new Person1(“吴奇隆”,40));
ts.add(new Person1(“高圆圆”,22));

遍历方法1
// System.out.println(“开始遍历”);
// ts.forEach(s->System.out.println(s.name+":"+s.age));
// System.out.println(“开始遍历”);

遍历方法2
// System.out.println(“开始遍历”);
// for(Person1 p : ts) {
// System.out.println(p.name+":"+p.age);
// }
// System.out.println(“开始遍历”);

// 遍历方法3
System.out.println(“开始遍历”);
Iterator it = ts.iterator();
while(it.hasNext()) {
Person1 pt = (Person1) it.next();
System.out.println(pt.name+":"+pt.age);
}
System.out.println(“开始遍历”);
}

}

class Person1 implements Comparable{
String name;
int age;
public Person1() {

}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public Person1(String name,int age) {
this.name = name;
this.age = age;
}

@Override
public String toString() {
return “姓名:”+ this.name + “年龄:” + this.age;
}

@Override
public int compareTo(Person1 o) {
// TODO Auto-generated method stub
//按年龄排序
Person1 p1 = (Person1)o;
if(this.age>=p1.age)
{
return 1;
}
return -1;}

}
8、编写程序，创建一个TreeMap<String,String>集合保存5位学生的学号和姓名，该5名学生的学号为(“1”,“4”,“5”,“2”,“3”)、对应的姓名为 (“Lucy”,“Aimee”,“Amanda”,“John”,“Smith”)，令key值为学号，value值为姓名，根据学号从大到小的排序输出5位学生的信息。要求使用泛型，并会使用3种遍历方式输出。

import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

public class example08 {

public static void main(String[] args)
{
Map<String,String> treeMap = new TreeMap<String,String>(new Comparator(){

@Override
public int compare(Object o1, Object o2)
{
if(o1 == null || o2 == null)
return 0;
return String.valueOf(o1).compareTo(String.valueOf(o2));
}

});

treeMap.put(“1”, “小刘”);
treeMap.put(“4”, “小王”);
treeMap.put(“3”, “小虎”);
treeMap.put(“2”, “小何”);

//第一种只遍历key
for(String key : treeMap.keySet())
{
String value = treeMap.get(key);
System.out.println("key = “+key+” , value = "+value);
}
//第二种只遍历value
for(String value : treeMap.values())
{
System.out.println("value = "+value);
}
//第三种 entrySet遍历
Iterator iterator = treeMap.entrySet().iterator();
while(iterator.hasNext())
{
Map.Entry<String, String> set = (Entry<String, String>) iterator.next();
String key = set.getKey();
String value = set.getValue();
System.out.println("key = “+key+” , value = "+value);
}
}

}
9、编写一个程序，实现36选7，选出来的7个数不能重复，要求用List集合或Set集合来完成。要求使用泛型，并会使用3种遍历方式输出。

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Random;
public class T9_List {
public static void main(String[] args) {
Random rm=new Random();
List list = new ArrayList();
int count=0;
while(count<7) {
int num=rm.nextInt(36)+1;
if(!list.contains(num)) {
list.add(num);
count++;
}
}
//第一种方式遍历
Iterator it=list.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
System.out.println(“");
//第二种方式遍历
for(Object o:list) {
System.out.println(o);
}
System.out.println("”);
//第三种方式遍历
list.forEach(o->System.out.println(o));
}
}

import java.util.Iterator;
import java.util.TreeSet;
public class T9_Set {
public static void main(String[] args) {
TreeSet hs=new TreeSet<>();
while(hs.size()<7) {
int num=(int)(Math.random()36)+1;
hs.add(num);
}
//第一种遍历方法
for(Integer i:hs) {
System.out.println(i);
}
System.out.println("");
//第二种遍历方法
hs.forEach(o->System.out.println(o));
System.out.println("*");
//第三种遍历方法
Iterator it=hs.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
}

10、模拟软件学院的三个老师同时分发80份学习笔记，每个老师相当于一个线程。

package student;

public class demo {

public static void main(String[] args) {
// TODO Auto-generated method stub
Teacher t = new Teacher();
new Thread(t,“老师1”).start();
new Thread(t,“老师2”).start();
new Thread(t,“老师3”).start();
}

}

class Teacher implements Runnable{
private int ticketpaper=80;

public void run(){
while(true){
if(ticketpaper>0){
Thread teacher=Thread.currentThread();
String teacher_name=teacher.getName();
System.out.println(teacher_name+“正在发第”+ticketpaper–+“份试卷”);
}
}
}

}
11、编写一个多线程程序，模拟火车售票窗口售票的功能。创建线程1和线程2，通过这两个线程共同售出100张票。

package student;

public class demo {

public static void main(String[] args) {
// TODO Auto-generated method stub
Teacher t = new Teacher();
new Thread(t,“窗口1”).start();
new Thread(t,“窗口2”).start();

}

class Teacher implements Runnable{
private int ticketpaper=80;

}
12、编写一个程序，使用字节流拷贝一个jpg格式文件。（文件名以及文件路径自定）
package student;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class demo1 {

public static void main(String[] args) {
// TODO Auto-generated method stub
try {
FileInputStream input = new FileInputStream(“C:\Users\hyf\Pictures\Camera Roll\timg.jpg”);
// available()不受阻塞读取（或跳过）的估计剩余字节数。
byte[] b = new byte[input.available()];

input.read(b);
input.close();

FileOutputStream output = new FileOutputStream(“C:\Users\hyf\Pictures\Camera Roll\timg.jpg”);

output.write(b);output.close();

} catch (IOException e) {
e.printStackTrace();
}

}

13、编写一个程序，使用字符流拷贝一个文本文件。（文件名以及文件路径自定）

package student;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class demo1 {
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
BufferedReader bf = new BufferedReader(new FileReader(“C:\Users\hyf\Desktop\test.txt”));
BufferedWriter bw = new BufferedWriter(new FileWriter(“C:\Users\hyf\Desktop\des2.txt”));
String str;
while ((str = bf.readLine()) != null) {
bw.write(str);
bw.newLine();
}
bf.close();
bw.close();

}

14、把ArrayList集合中的字符串数据存储到文本文件。（字符串数据及文本文件的路径、文件名自定）

package student;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

public class demo1 {

public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
// 封装数据与(创建集合对象)
ArrayList array = new ArrayList();
array.add(“hello”);
array.add(“world”);
array.add(“java”);
// 封装目的地
BufferedWriter bw = new BufferedWriter(new FileWriter(“a.txt”));
// 遍历集合
for (String s : array) {
// 写数据
bw.write(s);
bw.newLine();
bw.flush();
}

// 释放资源
bw.close();
}

}

15、从文本文件中读取数据(每行为一个字符串)到集合中，并遍历集合。（文本文件的路径、文件名、文件数据均自定）

package studnet;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;

public class demo1 {

public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
// 封装数据源
BufferedReader br = new BufferedReader(new FileReader(“b.txt”));
// 封装目的地(创建集合对象)
ArrayList array = new ArrayList();

// 读取数据存储到集合中
String line = null;
while ((line = br.readLine()) != null) {
array.add(line);
}

// 释放资源
br.close();

// 遍历集合
for (String s : array) {
System.out.println(s);
}
}

}

16、计算从今天算起，100天以后是几月几号，并格式化成xxxx年x月x日的形式打印出来。
package chapter5.常用类;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
//计算从今天算起，100天以后是几月几号，并格式化成xxxx年x月x日的形式打印出来。//
public class T16 {
public static void main(String[] args) {
Calendar calendar=Calendar.getInstance();
calendar.add(Calendar.DATE, 100);
Date date=calendar.getTime(); //将Calendar对象转换成Date类型
SimpleDateFormat sdf=new SimpleDateFormat(“yyyy年MM月dd日”);
System.out.println(sdf.format(date)); //String.format(date) 是将Date转换成字符串
}

17、编写一个程序，实现字符串大小写的转换并倒序输出。

package student;

import java.util.Scanner;

public class demo1 {

public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scan = new Scanner(System.in);
String str = scan.next();

char[] ch = str.toCharArray();
StringBuffer sb = new StringBuffer();
for (int i = str.length() - 1; i >= 0; i–) {
if (ch[i] >= ‘A’ && ch[i] <= ‘Z’) {
sb.append(String.valueOf(ch[i]).toLowerCase());
} else if (ch[i] >= ‘a’ && ch[i] <= ‘z’) {
sb.append(String.valueOf(ch[i]).toUpperCase());
}
}
System.out.println(sb.toString());
}

}

1、Java语言中，运算符和某个类中的equals()方法的区别是什么?
（1）: 基本类型：比较的是数值是否相同引用类型：比较的是地址值是否相同
（2）:equals()方法：只能比较引用类型。默认情况下，比较的是地址值是否相同。但是，我们可以根据自己的需要重写该方法。

2、Java语言中，字符串的特点有哪些？
（1）:字符串一旦被赋值，就不能改变。这里指的是字符串的内容不能改变，而不是引用不能改变。
（2）:字符串直接赋值方式，其底层实现是：先去字符串常量池里面去找，如果有就直接返回，如果没有，就创建并返回。
（3）:字面值作为字符串对象和通过构造方法创建对象的不同，前者会创建1个对象，后者创建2个对象。

3、Java语言中，String,StringBuffer,StringBuilder的区别?
（1）:String是内容不可变的，而StringBuffer,StringBuilder都是内容可变的。
（2）:StringBuffer是同步的，数据安全,效率低;StringBuilder是不同步的,数据不安全,效率高。

4、简要说明Java语言中单例设计模式的实现步骤。
（1）:使用private关键字私有化构造方法；
（2）:在类的内部创建一个该类的实例对象，并使用私有的静态变量引用该对象；
（3）:为了让类的外部能够获得类的实例对象，需要定义一个公有的静态方法，用于返回该类实例。

5、什么是集合，请列举集合中常用的类和接口？
答：为了使程序能方便的存储和操作数目不固定的一组数据，JDK提供了一套类库，这些类都位于java.util包中，统称为集合。
集合框架中包含3个接口，分别是List、Set、Map。
常用的类包括有ArrayList、LinkedList、HashSet、TreeSet、HashMap、TreeMap。

6、请简述TreeSet集合保证唯一性的两种方式
（1）:使用自然排序:集合元素所在的类实现Comparable接口，并重写compareTo()方法。
（2）:使用比较器排序：创建TreeSet时调用带参构造方法，其参数为Comparator接口对象，可定义一个比较器类实现Comparator接口并重写compare()方法。

7、Java语言中，List的实现类ArrayList、Vector、LinkedList特点？
答：ArrayList:底层数据结构是数组，查询快，增删慢。线程不安全，效率高。
Vector：底层数据结构是数组，查询快，增删慢。线程安全，效率低。
LinkedList：底层数据结构是链表，查询慢，增删快。线程不安全，效率高。

8、Java语言中，使用泛型有什么好处？
（1）:限定了装入集合的元素类型，将运行时期的问题提前到了编译期间；
（2）:避免了强制类型转换。

9、Hashtable和HashMap的区别?
（1）:Hashtable:线程安全，效率低。不允许null键和null值；
（2）:HashMap:线程不安全，效率高。允许null键和null值。

10、集合中的List、Set、Map有什么区别？
（1）:List的特点是元素有序、不唯一。List接口的主要实现类有ArrayList和LinkedList。
（2）:Set的特点是元素无序、唯一。Set接口的主要实现类有HashSet和TreeSet。
（3）:Map的特点是存储的元素是键(Key)、值(Value)映射关系，元素都是成对出现的。Map接口的主要实现类有HashMap和TreeMap。

11、Java语言中，Map和Collection的区别是什么?
（1）:Map 存储的是键值对形式的元素，键唯一，值可以重复。
（2）:Collection 存储的是单独出现的元素，子接口Set元素唯一，子接口List 元素可重复。

12、Java语言中，Collection和Collections的区别是什么?
（1）:Collection 是单列集合的顶层接口，有两个子接口List和Set。
（2）:Collections 是针对Collection集合进行操作的工具类，可以对Collection 集合进行排序和查找等操作。

13、Java语言的I/O流中，close()方法和flush()方法的区别是什么?
（1）:close()方法关闭流对象，但是先刷新一次缓冲区。关闭之后，流对象不可以继续再使用了。
（2）:flush()方法仅仅刷新缓冲区,刷新之后，流对象还可以继续使用。

14、Java语言中，多线程有几种实现方案，分别是哪几种?
答：有3种多线程实现方案。
（1）:继承Thread类；
（2）:实现Runnable接口；
（3）:实现Callable接口。

15、Java语言中，实现线程同步有几种方式? 分别是什么?
答：实现线程同步有3种方式。
（1）:使用同步代码块；
（2）:使用同步方法；
（3）:使用同步锁。

16、Java语言中，启动一个线程是run()还是start()?它们的区别是什么?
答：启动一个线程是start()方法;
run():封装了被线程执行的代码,直接调用仅仅是普通方法的调用；
start():启动线程，并由JVM自动调用run()方法。

17、Java语言中，sleep()和wait()方法的区别是什么？
答： sleep():必须指定时间;不释放锁。
wait():可以不指定时间，也可以指定时间;释放锁。

18、在Java语言中，为什么wait(),notify(),notifyAll()等方法都定义在Object类中而不是Thread类中?
答：因为这些方法的调用是依赖于锁对象的，而同步代码块的锁对象是任意锁。
而Object类代表任意的对象，所以wait(),notify(),notifyAll()等方法就定义在Object类。

19、Java语言中，AWT与SWing的区别与联系是什么？
(1):java.awt:使用操作系统所提供组件风格来构建java的GUI组件,与系统关联较强，称为重量级控件。
(2):javax.swing:纯Java编写，与本地操作系统无关，具有平台无关性，称为轻量级控件。
(3):Swing 架构在 AWT 之上，是AWT的扩展而不是取代。

20、请简述适配器类的作用。
(1):JDK提供了一些适配器类，它们是监听器接口的默认实现类，这些实现类中实现了接口的所有方法，但方法中没有任何代码。
(2):可以在程序代码中定义一个类继承适配器类来达到实现监听器接口的目的。

21、简述如何实现GUI中的事件监听机制
(1):通过定义一个类实现XxxListener接口或者继承XxxAdapter类来得到一个事件监听器类，并对处理监听动作的方法进行重写；
(2):创建事件源对象和事件监听器对象；
(3):调用事件源的addXxxLisntener()方法，为事件源注册事件监听器对象。

1、Java语言中，什么是方法重载？
是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数的类型或参数的个数。调用这些同名的方法时，JVM会根据实际参数的不同绑定到不同的方法。

2、Java语言中，什么是方法重写？
在继承关系中，子类的方法与父类的某一方法具有相同的方法名、返回类型和参数列表，则称子类的该方法重写(覆盖)父类的方法

3、请简述Java语言中成员变量和局部变量的区别。
(1)、在类中的位置不同
成员变量：类中方法外。
局部变量：方法定义中或者方法声明上。
(2)、在内存中的位置不同
成员变量：在堆中。
局部变量：在栈中。
(3)、生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失。
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失。
(4)、初始化值不同
成员变量：有默认值。
局部变量：没有默认值，必须定义，赋值，然后才能使用。

4、请简述Java语言中构造方法的特点。
(1)、构造方法名与类名相同。
(2)、在构造方法名的前面没有返回值类型的声明。
(3)、在构造方法中不能使用return语句返回一个值。

5、构造方法和普通的成员方法有什么区别？
(1)、构造方法是类的一个特殊成员，它会在类实例化对象时被自动调用。而普通方法只有在使用的时候才会被调用。
(2)、在定义构造方法时要求方法名与类名相同、在方法名的前面没有返回值类型的声明、在方法中不能使用return语句返回一个值。

6、Java语言中，静态关键字static修饰的成员有哪些特点？
A:随着类的加载而加载。
B:优先于对象存在。
C:被类的所有对象共享。
D:既可以通过对象名调用，也可以通过类名调用，建议通过类名调用。

7、Java语言中，静态变量和成员变量的区别有哪些？
A:所属不同
静态变量：属于类，称为类变量。
成员变量：属于对象，称为对象变量，实例变量。
B:内存位置不同
静态变量：方法区的静态区。
成员变量：堆内存。
C:生命周期不同
静态变量：静态变量是随着类的加载而加载，随着类的消失而消失。
成员变量：成员变量是随着对象的创建而存在，随着对象的消失而消失。
D:调用不同
静态变量：可以通过对象名调用，也可以通过类名调用。
成员变量：只能通过对象名调用。

8、Java语言中，成员变量和成员方法的访问修饰符有哪些？其访问权限如何？
public : 该类或非该类均可访问，不同包中的类也能访问。
protected: 相同包中的类可访问,不同包中的子类也能访问。
默认(缺省): 相同包中的类可访问,不同包中的类不能访问。
private: 只有本类可以访问,同一个或者不同包中的类不能访问。

9、Java语言中，this关键字的含义是什么？有哪些作用？
(1)、this关键字的含义：指代类对象本身
(2)、this 关键字的作用：
a:在定义类时如果方法参数或方法中定义的局部变量与类中的变量同名，可以通过this做前缀以示区别。
b:类中有多个重载的构造方法时，构造方法中可以通过this()调用本类的其他构造方法，但必须是构造方法中的第一条语句。

10、Java语言中，super关键字的含义是什么？有哪些作用？
(1)、super关键字的含义：指代父类对象引用（super代表父类存储空间的标识）。
(2)、super关键字的作用：
a:访问被子类隐藏的父类同名成员变量和成员方法。
b:调用父类构造方法,且必须在子类构造方法的第一条代码。

11、Java语言中，abstract修饰符的特点有哪些？
(1)、abstract可修饰类和方法。
(2)、abstract修饰的类称为抽象类，不能被实例化。
(3)、抽象方法必须声明在抽象类中，且该方法不能有方法体。
(4)、抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类。
.

12、Java语言中，final修饰符的特点有哪些？
(1)、final修饰的类称为最终类，不能被继承；
(2)、final修饰的方法称为最终方法，不能被覆盖(重写)；
(2)、final修饰的变量是一个常量,不能被改写(重新赋值)。

13、Java语言中，多态的含义是什么？
多态就是使用父类类型的变量引用子类对象，根据被引用子类对象的不同特性，程序会得到不同的运行效果。

14、简要概述Java语言中break、continue、return语句的区别。
break:跳出单层循环。
continue:跳出一次循环，进入下一次的执行。
return:若有返回值，结束方法并返回一个值给调用者；若无返回值，结束方法的执行。

15、简要概述Java语言中实现多态的3个前提条件。
(1)、有子类继承父类或者实现类实现接口关系。
(2)、父子类之间或实现类与接口之间有方法重写。
(3)、有父类或者父接口引用指向子类对象。

16、简述Java语言中抽象类和接口的区别。
(1)、用abstract修饰的类称为抽象类。抽象类不能被实例化，需要定义一个子类来继承抽象类，子类对象可以赋值给抽象类引用变量。
(2)、接口是一种特殊的抽象类，接口中只能定义常量和抽象方法。在定义接口时需要使用interface关键字。

17、简述Java语言中类与类,类与接口,接口与接口之间的关系。
(1)、类与类
继承关系，只能单继承，可以多层继承。
(2)、类与接口
实现关系，可以单实现，也可以多实现。
还可以在继承一个类的同时，实现多个接口。
(3)、接口与接口
继承关系，可以单继承，也可以多继承。

18、请简述@FunctionalInterface注解的作用。
该注解只是显示的标注了接口是一个函数式接口，并强制编辑器进行更严格的检查，确保该接口是函数式接口，如果不是函数式接口，那么编译器就会报错，而对程序运行并没有实质上的影响。

19、简述什么是方法引用与构造器引用。
Lambda表达式的主体只有一条语句时，程序不仅可以省略包含主体的花括号，还可以通过英文双冒号“::”的语法格式来引用方法和构造器（即构造方法），这两种形式可以进一步简化Lambda表达式的书写，其本质都是对Lambda表达式的主体部分已存在的方法进行直接引用，主要区别就是对普通方法与构造方法的引用而已。

20、Java语言中，编译期（受检）异常和运行期（非受检）异常的区别？
编译期异常：必须要处理的，否则编译不通过。
运行期异常：可以不处理，也可以处理。
21、Java语言中，throw和throws是的区别？
hrows:
在方法声明上,后面跟的是异常的类名,可以是多个。
throws声明方法有异常，是一种可能性，这个异常并不一定会产生。
throw:
在方法体中,后面跟的是异常对象名,并且只能是一个。
throw抛出的是一个异常对象，说明这里肯定有一个异常产生了。

22、编译期异常的处理方案有几种，分别是什么？
有两种。
方式1：使用try…catch…finally语句对异常进行捕获处理。
方式2：使用throws关键字声明抛出异常，由调用者对抛出的异常进行处理。

本文地址：https://blog.csdn.net/qq_45480752/article/details/112216543