那年我梳理的Java编程题
SE阶段代表性编程题
1.打印九九乘法表（双重for循环）
public class TestStudy {
/**
* 打印九九乘法表
* @param args
*/
public static void main(String[] args) {
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(i+"x"+j + "=" + i*j +" ");
}
System.out.println();
}
}
}
2.打印水仙花数
/*
编程实现所有三位数水仙花数的打印
*/
public class TestWaterFlower{
public static void main(String[] args){
//1.打印所有的三位数
for(int i = 100; i <= 999; i++){
//2.拆分该三位数中的每个数字 123
int ia = i / 100; //获取百位数
int ib = i % 100 / 10; //获取十位数
int ic = i % 10; //获取个位数
//3.判断i代表的数值是否为水仙花数，若是则打印
if((ia*ia*ia + ib*ib*ib + ic*ic*ic) == i){
System.out.println(i);
}
}
}
}
3.数组的增删改查
数组增删不便,牵一发而动全身
查找方便,支持下标访问
Arrays.sort(arr);调用方法进行数组排序,底层实现方式是:快速排序
编程实现双色球:
package cn.xdl.test;
import java.util.Arrays;
import java.util.Random;
public class TestStudy {
public static void main(String[] args) {
int[] arr = new int[6];
//调用随机函数
Random random = new Random();
for (int i = 0; i < 6; i++) {
//调用随机函数生成1~33之间的随机数并对数组进行赋值
arr[i] = random.nextInt(33)+1;
//针对每次生成的随机号码进行去重操作
for (int j = i-1 ; j >=0 ;j--) {
//如果有相等,i--重新执行生成操作
if(arr[i] == arr[j]){
i--;
break;
}
}
}
Arrays.sort(arr);//排序
int red = random.nextInt(16)+1;
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]+" ");
}
System.out.println(red);
}
}
编程实现五子棋(控制台版):二维数组
package cn.yimu.goband;
/*
编程实现控制台版的五子棋游戏，支持两人对战
*/
import java.util.Scanner;
public class Goband {
//自定义二维数组来描述棋盘，默认初始值为0
int[][] chessBoard = new int[16][16];
//自定义成员方法来绘制棋盘
void paint(){
//1.先绘制棋盘中第一行的坐标信息，也就是列坐标信息
for(int i = 0; i < 17; i++){
if(i == 0){
System.out.print(" ");
}
else{
//按照十六进制的格式打印i-1的数值
System.out.printf("%x ", i-1);
}
}
System.out.println();
//2.绘制棋盘中除了第一行之外的其他部分以及行坐标信息
for(int i = 0; i < 16; i++){
//用于打印行坐标信息
System.out.printf("%x ", i);
for(int j = 0; j < 16; j++){
//刚开始棋盘中的所有内容都是+，因此直接打印
if(chessBoard[i][j] == 0){
System.out.print("+ ");
}
else if(chessBoard[i][j] == 1){
System.out.print("● ");
}
else{
System.out.print("○ ");
}
}
//打印完毕一行的所有内容之后进行换行
System.out.println();
}
}
//自定义成员方法来提示黑方和白方分别下棋
void play(){
//定义标志位来进行黑方和白方的切换，true代表黑方，false代表白方
boolean flag = true;
//不断地分别提示黑方和白方下棋
while(true){
System.out.println("请" + (flag ? "黑方": "白方") + "输入落子坐标(x y)：");
Scanner sc = new Scanner(System.in);
int ix = sc.nextInt();
int iy = sc.nextInt();
//根据用户输入的坐标来调整棋盘中的图案，策略为改变数组的元素值
if(flag){
//当黑方落子时就将数组中对应元素值改为1
chessBoard[ix][iy] = 1;
}else{
//当白方落子时就将数组中对应元素改为2
chessBoard[ix][iy] = 2;
}
//重新绘制图案
paint();
//判断当前方是否胜利，若胜利就立刻结束游戏
if(judge(ix, iy)){
System.out.println("恭喜" + (flag ? "黑方": "白方") + "胜利了！");
break;
}
//此时切换下棋方
flag = !flag;
}
}
//自定义成员方法来判断用户是否获胜，获胜的规则是：任意相同颜色的5个棋子连成一线
boolean judge(int ix, int iy){
//1.判断竖向是否连成一线，则需要以该点为中心向上四个点向下四个点
//声明变量来统计竖向相同颜色棋子的个数，先统计向上同色棋子的个数
int count = 1;
for(int i = ix-1; i >= 0 && i >= ix-4; i--){
//若当前点代表的棋子与上述某个点代表的棋子不一样，则向上统计结束
if(chessBoard[ix][iy] != chessBoard[i][iy]){
break;
}
count++;
}
System.out.println("count1 = " + count);
//再统计向下颜色相同的个数
for(int i = ix+1; i <= 15 && i <= ix+4; i++){
if(chessBoard[ix][iy] != chessBoard[i][iy]){
break;
}
count++;
}
System.out.println("count2 = " + count);
//... ...
return count >= 5;
//当所有可能胜利的情况都排除了，那么肯定是失败了
}
}
启动类:
public class TestGoband {
public static void main(String[] args) {
//1.声明一个GoBand类型的引用指向该类的对象
Goband gb = new Goband();
//2.调用成员方法来绘制棋盘
gb.paint();
//3.调用成员方法来进行下棋
gb.play();
}
}
4.递归方法的调用
所谓递归就是自己调用自己的方法:
递归有可能会大幅简化代码的编写。递归要考虑性能问题，有些时候可以使用循环而不是递归。
递归的使用原则:
1 必须有退出条件。
2 必须使问题变简单，而不是复杂化。
递归方式实现阶乘:
public class TestDG {
/**
* 自定义算法实现阶乘
* 阶乘:1*2*3*4...*n
* @param n
* @return
*/
int factorial(int n){
if(n == 1){
return 1;
}
return n*factorial(n-1);
}
public static void main(String[] args) {
TestDG dg = new TestDG();
System.out.println(dg.factorial(4));
}
}
费时数列的递归实现
public class TestDG {
/**
* 自定义递归实现费式数列
* 费式数列:也叫斐波那契数列:即从1开始,后一个数等于前两个数之后1、1、2、3、5、8、13、21...
* @return
*/
int sequence(int n){
if(n == 1 || n == 2){
return 1;
}
return sequence(n-1)+sequence(n-2);
}
public static void main(String[] args) {
TestDG dg = new TestDG();
System.out.println(dg.sequence(45));
}
}
5.单例设计模式（饿汉式，懒汉式）
饿汉式:
public class Singleton(){
//1 私有化构造方法
private Singleton(){}
//2 提供一个本类类型的引用指向本类的对象
private static Singleton sin = new Singleton();
//3 提供一个公用的方法将sin的数值返回出去
public static Singleton getInstance(){
return sin;
}
}
懒汉式:
public calss Singleton(){
private Singleton(){};
private static Singleton sin = null;
public static Singleton getInstance(){
if(sin == null){
sin = new Singleton();
}
return sin;
}
}
6.匿名内部类
Thread th = new Thread(){
编写代码;
};
7.自定义异常类
自定义异常类:继承自Exception
public class AgeException extends Exception{
编写代码;
}
8.递归实现多层文件读取文件名
import java.io.File;
public class PrintList {
/**
* 自定义方法打印参数指定目录及其子目录中的文件
* @param file
*/
public static void print(File file){
// 判断是否是普通文件
if(file.isFile()){
System.out.println(file.getName());
}else if(file.isDirectory()){
//获取目录中的所用内容
File[] fArr = file.listFiles();
//使用递归,打印所有
for (File f: fArr) {
print(f);
}
}
}
public static void main(String[] args) {
File file = new File("目录或者文件名");
PrintList.print(file);
}
}
9.使用byte[] 实现文件的拷贝
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class FileCopy {
public static void main(String[] args) {
try {
//文件流对象,关联需要拷贝文件
FileInputStream fis = new FileInputStream("输出文件名");
FileOutputStream fos = new FileOutputStream("输入文件名");
//准备一个合理的缓存区,每次只需要将缓存区写满再写入
byte[] brr = new byte[1024*8];
int res =0;
while((res = fis.read(brr)) != -1){
fos.write(brr,0,res);
}
fis.close();
fos.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
10.多线程的实现方式（扩展）
方式一:继承Thread类
/**
* 1 继承Thread类
* 2 重写run方法
* 3 调用start()开启线程
* @author liangmu
*/
public class WayThread extends Thread{
@Override
public void run(){
for (int i = 0; i < 26; i++) {
System.out.println(“线程一:” + i);
}
}
public static void main(String[] args) {
Thread th = new WayThread();
th.start();//启动一个线程的方法
for (int i = 0; i < 21; i++) {
System.out.println(“main线程:”+ i);
}
}
}
方式二:实现Runnable接口
/**
* 方式二
* 1 实现Runnable接口
* 2 重写run方法
* 3 开启线程
* @author liangmu
*
*/
public class WayThread implements Runnable{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("子线程:" + i);
}
}
public static void main(String[] args) {
Runnable ra = new WayThread();
Thread th = new Thread(ra);
th.start();
for (int i = 0; i < 100; i++) {
System.out.println("主线程方法:" + i);
}
}
}
方式三:匿名内部类
/**
* 方式三:
* 使用匿名内部类的方式调用
* @author liangmu
*
*/
public class WayThread{
public static void main(String[] args) {
Thread th = new Thread(){
public void run(){
for (int i = 0; i < 30; i++) {
System.out.println("线程一" + i);
}
}
};
th.start();
new Thread(){
public void run(){
for (int i = 0; i < 30; i++) {
System.out.println("线程二" + i);
}
}
}.start();
}
}
11.基于TCP协议的网络编程（UDP协议 扩展）
客户端:
public class TestClient {
public static void main(String[] args) {
try{
//1.创建Socket类型的对象，并提供服务器的IP地址和端口号
Socket s = new Socket("localhost", 8888);
//2.使用输入输出流进行通信
PrintStream ps = new PrintStream(s.getOutputStream());
BufferedReader br = new BufferedReader(
new InputStreamReader(s.getInputStream()));
Scanner sc = new Scanner(System.in);
while(true){
//String msg = "在吗？";
System.out.println("请输入要发送的内容：");
String msg = sc.nextLine();
ps.println(msg);
System.out.println("发送数据成功！");
//判断客户端给服务器发送的内容是否为"bye"
if("bye".equalsIgnoreCase(msg)){
System.out.println("再见吧！");
break;
}
//接收服务器回发的消息
String str = br.readLine();
System.out.println("服务器发来的数据是：" + str);
}
//3.关闭Socket并释放有关的资源
br.close();
ps.close();
s.close();
}catch(Exception e){
e.printStackTrace();
}
}
}
服务端:
import java.net.ServerSocket;
import java.net.Socket;
public class TestServer {
public static void main(String[] args) {
try {
//创建ServerSocket类型的对象,并提供端口号
ServerSocket ss = new ServerSocket(8888);
while(true){
System.out.println("等待客户端连接请求...");
Socket s = ss.accept();
System.out.println(s.getInetAddress()+"连接成功");
ServerThread thread = new ServerThread(s);
Thread th = new Thread(thread);
th.start();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
线程:
public class ServerThread implements Runnable{
private Socket s;
public ServerThread(Socket s){
this.s = s;
}
@Override
public void run(){
try{
//3.使用输入输出流进行通信
BufferedReader br = new BufferedReader(
new InputStreamReader(s.getInputStream()));
PrintStream ps = new PrintStream(s.getOutputStream());
while(true){
String str = br.readLine();
System.out.println("客户端" + s.getInetAddress()
+ "发来的数据是：" + str);
//判断客户端发来的数据是否为"bye"，若是则结束通信
if("bye".equalsIgnoreCase(str)){
System.out.println("话不投机半句多！客户端"
+ s.getInetAddress() + "已下线！");
break;
}
//实现服务器向客户端回发消息
ps.println("I received!");
System.out.println("服务器发送数据成功！");
}
//4.关闭Socket并释放有关的资源
ps.close();
br.close();
s.close();
}catch(Exception e){
e.printStackTrace();
}
}
}
12.冒泡算法(快速算法 扩展)
public class TestSort(){
public static void bubble(int[] arr){
//1.使用外层for循环来控制比较的轮数
for(int i=1;iarr[j+1]){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
flag = false;
}
}
if(flag) break;
}
}
public static void main(String[] args){
int[] arr = {12,32,25,2,6,86,63,21,15,36};
TestSort.bubble(arr);
for(int i=0;i 13.工厂模式 抽象工厂模式(23种设计模式 扩展)
设计模式: 设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。设计模式本质上就是一种固定的套路，使用在固定的场合中。
分类:
创建型模式 - 工厂方法模式、抽象工厂模式、单例设计模式。
结构型模式 - 装饰器模式、代理模式。
行为型模式 - 模板设计模式、观察者模式。
1、工厂方法模式（Factory Method）:
普通工厂模式:(邮件和短信的例子)
接口:
public interface Sender{
public void send();
}
接口实现类:
public class MailSender implements Sender {
@Override
public void send() {
System.out.println("邮件发送");
}
}
public class SmsSender implements Sender {
@Override
public void send() {
System.out.println("信息发送");
}
}
工厂类:
public class SendFactory {
//工厂方法
public Sender produce(String type){
if ("mail".equals(type)) {
return new MailSender();
} else if ("sms".equals(type)) {
return new SmsSender();
} else {
System.out.println("请输入正确的类型!");
return null;
}
}
}
工厂测试类:
public class TestFactory {
public static void main(String[] args) {
SendFactory sendFactory = new SendFactory();
Sender sms = sendFactory.produce("sms");
sms.send();
}
}
多个工厂方法模式:
即在工厂类中添加多个工厂方式
静态工厂方法模式:
即将工厂类中的方法设置为静态的加static,不需要创建实例,可直接调用
抽象工厂模式
工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码
接口:
实现类:
工厂类实现接口方法:
测试类:
14.学生信息管理系统
c/s架构编写,SE阶段最具代表性的项目