JAVA练习500题2帖超详细带答案持续更新中~

本文链接：https://blog.csdn.net/2401_84433853/article/details/138016105

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注Java）
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

正文

//4.判断max与a[i]的大小
if(a[i] > max){
max = a[i];//让max保存的一直都是目前遍历到的最大值
}
}
//4.循环结束,输出数组中的最大值
System.out.println(“最大值为:”+max);
}

private static void f1() {
//需求1:求出数组中所有的元素之和
//1.定义一个数组
int[] a = {1, 2, 3, 4, 5};
//2.定义一个变量用来保存最终的结果
int sum = 0;
//3.用数组的遍历来进行数据的累加
//i:下标 0 a.length-1 ++
for (int i = 0; i <= a.length - 1; i++) {
sum += a[i];
}
System.out.println(“数组元素累计的和为:” + sum);
}
}

练习题 : 数组练习2

需求: 将数组中的所有元素逆序输出(3种)
package cn.tedu.basic;

import java.util.Arrays;

/*需求: 将数组中的所有元素逆序输出(3种)*/
public class TestArray2 {
public static void main(String[] args) {
//f1();//实现思路1
//f2();//实现思路2
f3();//实现思路3
}

private static void f3() {
//1.准备原数组
int[] a = {100, 200, 300, 400, 500, 600};
//2.遍历数组,将数组中对应位置上的元素交换位置
for (int i = 0; i < a.length / 2; i++) {
//3.准备一个第三方变量协助数组中的两个元素互换值
//a[0] <-> a[a.length-1-0]
//a[1] <-> a[a.length-1-1]
//a[2] <-> a[a.length-1-2]
//a[i] <-> a[a.length-1-i]
int temp = a[i];
a[i] = a[a.length-1-i];
a[a.length-1-i] = temp;
}
System.out.println(Arrays.toString(a));
}

private static void f2() {
//1.准备原数组
int[] a = {10, 20, 30, 40, 50};
//2.准备一个新数组,数组的长度与原数组长度相同
int[] b = new int[a.length];
//3.准备循环,遍历原数组,并将遍历到的元素复制到新数组中
//i=0,a[0]->b[4]
//i=1,a[1]->b[3]
//i=2,a[2]->b[2]
//i=3,a[3]->b[1]
//i=4,a[4]->b[0]
for (int i = 0; i < a.length; i++) {
b[b.length - 1 - i] = a[i];
}
System.out.println(Arrays.toString(b));
a = b;//把b保存的地址值交给a,这样a b两个引用类型变量保存的是同一个数组的地址值
System.out.println(Arrays.toString(a));
}

private static void f1() {
//1.准备数组
int[] a = {1, 2, 3, 4, 5};
//2.倒着输出
//i:下标从哪开始a.length-1 到哪结束0 如何变化–
for (int i = a.length - 1; i >= 0; i–) {
//3.把当前遍历到的元素输出
System.out.println(a[i]);
}
}
}

练习题 : 进制的前缀

package cn.tedu.basic;
/*本类用于测试类型的前缀*/
public class TestTypePre {
public static void main(String[] args) {
//10-2 10-1 10-0
System.out.println(100);//100-10的平方
//操作二进制-0b
//2-2 2-1 2-0
System.out.println(0b100);//4-2的平方
//操作八进制
//8-2 8-1 8-0
System.out.println(0100);//64-8的平方
//操作十六进制
//16-2 16-1 16-0
System.out.println(0x100);//256-16的平方
}
}

练习题 : 创建一个长度随机，内容随机的整形数组,并对这个数组进行升序排序

package cn.cxy.exec;

import java.util.Arrays;
import java.util.Random;

public class TestMethod {
public static void main(String[] args) {
//传入一个随机数组，进行排序，然后将排好序的数组返回
//1.用来生成一个随机数组
int[] a = createArray();
System.out.println(Arrays.toString(a));
//2.传入刚刚生成的随机数组，排序，将排序后的数组返回
int[] b = sortArray(a);
System.out.println(Arrays.toString(b));
}
public static int[] sortArray(int[] a){
//需要对传入的数组进行排序
Arrays.sort(a);
return a;
}
//修饰符返回值类型方法名(参数列表){方法体}
public static int[] createArray(){
//生成一个随机数组，并将结果返回
//1.动态创建一个长度随机的数组
//int length = new Random().nextInt(10);//[0,10)
int length = new Random().nextInt(5)+5;//[0,5)->[0+5,5+5)->[5,10)
int[] a = new int[length];//数组的长度是生成的随机长度length
/**数组长度可以为0*/
//2.遍历数组，依次向数组中的每个位置存入随机值
for(int i = 0;i<=a.length-1;i++) {
a[i] = new Random().nextInt(100);
}
return a;
}
}

练习题 : 创建一个长度随机，内容随机的整形数组,并对这个数组进行降序排序

package cn.cxy.exec;

import java.util.Arrays;
import java.util.Collections;
import java.util.Random;
public class TestMethod {
public static void main(String[] args) {
//传入一个随机数组，进行排序，然后将排好序的数组返回
//1.用来生成一个随机数组
Integer[] a = createArray();
System.out.println(Arrays.toString(a));
//2.传入刚刚生成的随机数组，排序，将排序后的数组返回
Integer[] b = sortArray(a);
System.out.println(Arrays.toString(b));
}
public static Integer[] sortArray(Integer[] a){
//需要对传入的数组进行排序
//Arrays.sort(a);
Arrays.sort(a,Collections.reverseOrder());
return a;
}
//修饰符返回值类型方法名(参数列表){方法体}
public static Integer[] createArray(){
//生成一个随机数组，并将结果返回
//1.动态创建一个长度随机的数组
//int length = new Random().nextInt(10);//[0,10)
int length = new Random().nextInt(5)+5;//[0,5)->[0+5,5+5)->[5,10)
Integer[] a = new Integer[length];//数组的长度是生成的随机长度length
/**数组长度可以为0*/
//2.遍历数组，依次向数组中的每个位置存入随机值
for(int i = 0;i<=a.length-1;i++) {
a[i] = new Random().nextInt(100);
}
return a;
}
}

练习题 : 完成减肥计划案例1

使用嵌套分支完成练习
接收用户输入的星期数，提示用户今天的减肥安排
星期一：跳绳
星期二：跑步
星期三：瑜伽
星期四: 普拉提
星期五：打网球
星期六：游泳
星期日：休息日不运动

package cn.cxy.exec;

import java.util.Scanner;

/*本类用于完成减肥计划，使用嵌套分支完成练习
接收用户输入的星期数，提示用户今天的减肥安排
* 星期一：跳绳
* 星期二：跑步
* 星期三：瑜伽
* 星期四: 普拉提
* 星期五：打网球
* 星期六：游泳
* 星期日：休息日不运动 */
public class ReduceWeight {
public static void main(String[] args) {
//1.提示并接收用户输入的星期数
System.out.println(“请输入今天的星期数：(1~7)”);
int day = new Scanner(System.in).nextInt();
//2.对用户输入的数据进行合理性判断
if (day < 1 || day > 7) {
System.out.println(“您输入的天数有误哦_{请重新输入}”);
}else{//输入正确的数据才会进一步判断
if(day == 1){
System.out.println(“今天周一，该去跳绳啦！”);
}else if(day == 2){
System.out.println(“今天周二，该去跑步啦！”);
}else if(day == 3){
System.out.println(“今天周三，该去做瑜伽啦！”);
}else if(day == 4){
System.out.println(“今天周四，该去做普拉提啦！”);
}else if(day == 5){
System.out.println(“今天周五，该去打网球啦！”);
}else if(day == 6){
System.out.println(“今天周六，该去游泳啦！”);
}else if(day == 7){
System.out.println(“今天周日，休息日，休息一天吧！”);
}
}
}

}

练习题 : 完成减肥计划案例2

使用选择结构完成练习
接收用户输入的星期数，提示用户今天的减肥安排
星期一：跳绳
星期二：跑步
星期三：瑜伽
星期四: 普拉提
星期五：打网球
星期六：游泳
星期日：休息日不运动

package cn.cxy.exec;

import java.util.Scanner;

/*本类用于完成减肥计划，使用选择结构完成练习
接收用户输入的星期数，提示用户今天的减肥安排
* 星期一：跳绳
* 星期二：跑步
* 星期三：瑜伽
* 星期四: 普拉提
* 星期五：打网球
* 星期六：游泳
* 星期日：休息日不运动 */
public class ReduceWeight2 {
public static void main(String[] args) {
//1.提示并接收用户输入的星期数
System.out.println(“请输入今天的星期数：(1~7)”);
int day = new Scanner(System.in).nextInt();
//2.对用户输入的星期数做判断
switch (day){
case 1 : System.out.println(“今天周一，该去跳绳啦！”);break;
case 2 : System.out.println(“今天周二，该去跑步啦！”);break;
case 3 : System.out.println(“今天周三，该去做瑜伽啦！”);break;
case 4 : System.out.println(“今天周四，该去做普拉提啦！”);break;
case 5 : System.out.println(“今天周五，该去打网球啦！”);break;
case 6 : System.out.println(“今天周六，该去游泳啦！”);break;
case 7 : System.out.println(“今天周日，休息日，休息一天吧！”);break;
//如果都没有匹配到，说明用户输入的数据不合理
default: System.out.println(“您输入的天数有误哦_{请重新输入}”);
}
}
}

练习题 : 实现一个简易的计算器

package cn.cxy.exec;

import java.util.Scanner;

public class TestMethod {
public static void main(String[] args) {
f0();//调用一个实现计算器的方法
}
private static void f0() {
while(true) {
//完成实现一个计算器的功能
//1.提示并接收用户要计算的两个数
System.out.println(“请您输入要计算的第一个数：”);
int a = new Scanner(System.in).nextInt();
System.out.println(“请您输入要计算的第二个数：”);
int b = new Scanner(System.in).nextInt();

//2.提示并接收用户输入的运算符
System.out.println("请输入您要计算的运算符：支持 + - * / ");
String s = new Scanner(System.in).nextLine();

//3.根据运算符调用不同的方法给出结果
switch(s) {
case “+” : f1(a,b);break;
case “-” : f2(a,b);break;
case “*” : f3(a,b);break;
case “/” : f4(a,b);break;
default :System.out.println(“输入的运算符不正确！”);
}
//4.询问用户是否想继续运算
System.out.println(“如果想退出，请输入1，继续请输入2”);
int flag = new Scanner(System.in).nextInt();
if(flag==1) break;//如果if后只有一句话，大括号可以省略，break退出死循环

}

}
private static void f4(int a,int b) {//进行除法运算
System.out.println(a+“与”+b+“的除法运算结果为：”+(a/b));
}
private static void f3(int a,int b) {//进行乘法运算
System.out.println(a+“与”+b+“的乘法运算结果为：”+(a*b));
}
private static void f2(int a,int b) {//进行减法运算
System.out.println(a+“与”+b+“的减法运算结果为：”+(a-b));
}
private static void f1(int a,int b) {//做加法运算的方法
System.out.println(a+“与”+b+“的加法运算结果为：”+(a+b));
}

}

练习题 : 方法的重载练习

方法一：传入两个int类型的参数，并返回这两个数的和，方法名为sum
方法二：传入两个double类型的参数，并返回这两个数的和，方法名为sum
方法三：传入一个double类型的参数，一个int类型的参数，并返回这两个数的和，方法名为sum
方法四：传入一个int类型的参数，一个double类型的参数，并返回这两个数的和，方法名为sum

package cn.tedu.method;
/*本类用于测试方法的重载
* 如果在同一个类中，存在多个同名方法，但参数列表不同的现象
* 作用：重载使我们的代码更灵活，传入不同的参数，都可以有对应的方法被调用
* 方法是否构成重载，与方法参数的类型有关，与方法参数的名字无关
* 前提：同一个类中，同名的方法
* 1.方法的参数个数不同：一定构成重载
* 2.方法的参数个数相同：就需要查看对应位置上参数的类型*/
public class TestMethod1 {
public static void main(String[] args) {
//f1();
int result = sum(1,2);
System.out.println(result);
double result2 = sum(5.5,1.1);
System.out.println(result2);
double result3 = sum(8.8,1);
System.out.println(result3);
double result4 = sum(7,2.2);
System.out.println(result4);
}
//1.方法一：传入两个int类型的参数，并返回这两个数的和，方法名为sum
public static int sum(int a,int b){
//return a+b;
int c = a+b;
return c;
}
//2.方法二：传入两个double类型的参数，并返回这两个数的和，方法名为sum
public static double sum(double aa,double bb){
// double cc = aa + bb;
// return cc;
return aa+bb;
}
//3.方法三：传入一个double类型的参数，一个int类型的参数，并返回这两个数的和，方法名为sum
public static double sum(double a,int b){
return a+b;
}
//4.方法四：传入一个int类型的参数，一个double类型的参数，并返回这两个数的和，方法名为sum
public static double sum(int a,double b){
return a+b;
}

private static void f1() {
//演示重载的现象
System.out.println(“HelloWorld”);
System.out.println(1);
System.out.println(4.5);
System.out.println(‘a’);
System.out.println(true);
}
}

练习题 : 面向对象练习：设计小狗类

定义一个小狗类Dog
属性：姓名name 年龄age 品种kind 主人host 价格price
功能：跑run 吃eat 睡觉sleep 玩play
要求：
1.创建所有的属性，并进行封装
2.创建本类的无参构造、含参构造(int n)、全参构造
3.利用3种不同构造方法创建三个对象d1 d2 d3
4.通过创建好的每一个对象，查看所有的属性，并调用所有的方法

package cn.cxy.exec;

public class TestDog {
public static void main(String[] args) {
//6.1创建Dog类的第1个对象并进行测试,触发的是无参构造
Dog d1 = new Dog();//我是Dog类的无参构造
//d1.age = 7;//不能用这种方式，因为age被封装了，会报错
d1.run();
d1.eat();
//6.2创建Dog类的第2个对象并进行测试,触发的是含参构造
Dog d2 = new Dog(100);//我是Dog类的含参构造100
System.out.println(d2.getName());//null
d2.sleep();
d2.play();
//6.3创建Dog类的第3个对象并进行测试，触发的是全参构造
Dog d3 = new Dog(“旺财”,6,“柴犬”,“黄飞鸿”,388.8);//我是Dog类的全参构造
/*打印的都是我们通过全参构造给对象属性设置的值*/
System.out.println(d3.getName());//旺财
System.out.println(d3.getAge());//6
System.out.println(d3.getHost());//黄飞鸿
System.out.println(d3.getKind());//柴犬
System.out.println(d3.getPrice());//旺财
d3.eat();
d3.sleep();
}
}
//1.定义Dog类
class Dog{
//2.定义Dog类的属性
//3.1封装所有属性
private String name;//姓名
private int age;//年龄
private String kind;//品种
private String host;//主人
private double price;//价格

//4.1提供本类的无参构造
public Dog(){
System.out.println(“我是Dog类的无参构造”);
}
//4.2提供本类的含参构造
public Dog(int n){
System.out.println(“我是Dog类的含参构造”+n);
}
//4.3提供本类的全参构造
public Dog(String name, int age, String kind, String host, double price) {
this.name = name;
this.age = age;
this.kind = kind;
this.host = host;
this.price = price;
System.out.println(“我是Dog类的全参构造”);
}

//5.1提供Dog自己的跑的功能
public void run(){
System.out.println(“小狗狗跑的老快了~”);
}
//5.2提供Dog自己的吃的功能
public void eat(){
System.out.println(“小狗爱吃肉骨头”);
}
//5.3提供Dog自己的睡觉的功能
public void sleep(){
System.out.println(“小狗一天睡几个小时来着？”);
}
//5.4提供Dog自己的玩的功能
public void play(){
System.out.println(“小狗爱玩飞盘~”);
}

//3.2提供所有的get与set方法
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 String getKind() {
return kind;
}

public void setKind(String kind) {
this.kind = kind;
}

public String getHost() {
return host;
}

public void setHost(String host) {
this.host = host;
}

public double getPrice() {
return price;
}

public void setPrice(double price) {
this.price = price;
}
}

练习题 : 面向对象练习：设计小猫类

测试类TestCat

定义一个小猫类Cat
定义属性: 名字name 年龄age 品种kind 主人host 价格price
封装所有的属性,提供所有属性对应的get与set方法
提供Cat无参构造与全参构造
提供功能:

吃eat:参数int n,无返回值,打印:小猫Cat今晚要吃n根肉骨头
跳jump:参数String name,无返回值,打印:小猫name跳的老高啦~
睡觉sleep:参数String name,double num无返回值,打印:小猫name今天一共睡了num个小时
玩play: 参数String host,返回值String"逗猫棒",打印:小猫与主人host玩的很开心
叫bark:打印:小猫喜欢喵喵叫,此方法要封装,玩的时候才叫

完成业务:每当创建小猫类的对象,就在控制台打印:又有一只可爱的小猫咪粗来啦~
完成测试:

1)创建小猫类的对象c1,使用无参构造创建
并调用set()给c1赋值:叮当 300 机器猫大雄 10000
赋值后使用get()查看是否赋值成功
2)使用全参构造创建小猫类对象c2,赋值:罗小黑 7 变异猫未知 800
赋值后使用get()查看是否赋值成功
3)创建小猫类的对象c3,通过c3对象调用小猫类的功能*5

package cn.tedu.oop;

public class TestCat {
public static void main(String[] args) {
//6.1使用无参构造创建对象
Cat c1 = new Cat();
//6.2通过set()给对象的属性赋值
c1.setName(“叮当”);
c1.setAge(300);
c1.setHost(“大雄”);
c1.setKind(“机器猫”);
c1.setPrice(10000);
//6.3通过get()查看对象的属性值
System.out.println(c1.getName());
System.out.println(c1.getHost());
System.out.println(c1.getAge());
System.out.println(c1.getPrice());
System.out.println(c1.getKind());

//7.1使用全参构造创建对象,并同时给对象的所有属性赋值
Cat c2 = new Cat(“罗小黑”,7,“变异猫”,“未知”,800);
//7.2查看对象的赋值是否成功
System.out.println(c2.getName());
System.out.println(c2.getHost());
System.out.println(c2.getAge());
System.out.println(c2.getPrice());
System.out.println(c2.getKind());

//8.1创建小猫类的对象
Cat c3 = new Cat();
//8.2通过创建好的小猫对象调用小猫类的功能
c3.eat(8);
c3.sleep(“罗小白”,9.9);
c3.jump(“花花”);
c3.play(“苏大强”);//只调用玩的功能,不接收返回值
String n = c3.play(“哈哈哈”);//再次调用play(),选择接收返回值
System.out.println(n);//把接到的玩具"逗猫棒"打印出来
}
}
//1.定义小猫类
class Cat{
//2.1提供所有属性并进行封装
private String name;//名字
private int age;//年龄
private String kind;//品种
private String host;//主人
private double price;//价格

//5.创建构造代码块,提取所有构造方法的共性功能
{
System.out.println(“又有一只可爱的小猫咪粗来啦~”);
}

//3.提供本类的无参与全参构造
public Cat() {
System.out.println(“无参构造”);
}
public Cat(String name, int age, String kind, String host, double price) {
this.name = name;
this.age = age;
this.kind = kind;
this.host = host;
this.price = price;
System.out.println(“全参构造”);
}

//4.提供小猫类的功能
//4.1睡觉sleep:参数String name,double num,无返回值,打印:小猫name今天一共睡了num个小时
public void sleep(String name,double num){
System.out.println(“小猫”+name+“今天一共睡了”+num+“个小时”);
}
//4.2玩play: 参数String host,返回值String"逗猫棒",打印:小猫与主人host玩的很开心
public String play(String host){
System.out.println(“小猫与主人”+host+“玩的很开心”);
bark();//此处调用被封装的方法
return “逗猫棒”;
}
//4.3叫bark:打印:小猫喜欢喵喵叫,此方法要封装,玩的时候才叫
private void bark(){
System.out.println(“小猫喜欢喵喵叫”);
}

//4.4吃eat:参数int n,无返回值,打印:小猫Cat今晚要吃n根肉骨头
public void eat(int n){
System.out.println(“小猫Cat今晚要吃”+n+“根肉骨头”);
}
//4.5跳jump:参数String name,无返回值,打印:小猫name跳的老高啦~
public void jump(String name){
System.out.println(“小猫”+name+“跳的老高啦~”);
}

//2.2给被封装的属性提供get与set方法
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 String getKind() {
return kind;
}

public void setKind(String kind) {
this.kind = kind;
}

public String getHost() {
return host;
}

public void setHost(String host) {
this.host = host;
}

public double getPrice() {
return price;
}

public void setPrice(double price) {
this.price = price;
}
}

练习题 : 面向对象练习：实现学生类

需求：创建学生类，按照上述步骤进行测试
学生的属性：学号姓名性别住址科目
学生的功能：学习吃饭睡觉查看本类类型与所有属性和属性值

创建学生类Student

package cn.tedu.oop;
/*本类用于描述学生这一类事物*/
public class Student {
//1.1定义学生的属性
//1.2 封装学生的属性
private int id;//学号
private String name;//姓名
private char gender;//性别
private String address;//住址
private String subject;//科目

//2.1提供本类的无参构造
public Student(){
System.out.println(“我是Student的无参构造”);
}
//2.2提供本类的全参构造
//右键->Generate->Contructor->Shift全选所有属性->OK
public Student(int id, String name, char gender, String address, String subject) {
this.id = id;
this.name = name;
this.gender = gender;
this.address = address;
this.subject = subject;
System.out.println(“我是Student的全参构造”);
}
//3.1提供本类的普通方法1
public void study(){
System.out.println(“学习使我快乐~”);
}
//3.2提供本类的普通方法2
public void eat(int n){
System.out.println(“今天我要干它”+n+“碗大米饭”);
}
//3.3提供本类的普通方法3
public String sleep(){
return “今天又睡了美美的一觉”;
}
//4.提供本类的一个展示类型与所有属性和属性值的方法
public void show(){
System.out.println(“Student:[id=”+id+“,name=”+name+“,gender=”+gender+“,address=”+address+“,subject=”+subject+“]”);
}

//1.3提供属性对应的get与set方法
//右键->Generate->Getter and setter->Shift全选所有属性->OK
public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getName() {
return name;
}

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

public char getGender() {
return gender;
}

public void setGender(char gender) {
this.gender = gender;
}

public String getAddress() {
return address;
}

public void setAddress(String address) {
this.address = address;
}

public String getSubject() {
return subject;
}

public void setSubject(String subject) {
this.subject = subject;
}
}

创建学生类的测试类TestStudent

package cn.tedu.oop;
/*本类用作学生类的测试类*/
public class TestStudnet {
public static void main(String[] args) {
//1.1使用无参构造创建对象
Student s = new Student();
//1.2通过setXxx()给对象的所有属性赋值
s.setId(1);
s.setName(“林冲”);
s.setGender(‘男’);
s.setSubject(“CGB”);
s.setAddress(“庙里”);
//1.3通过对象调用方法测试
s.study();
s.eat(3);
System.out.println(s.sleep());
s.show();//Student:[id=1,name=林冲,gender=男,address=庙里,subject=CGB]

//2.1使用全参构造创建对象
Student s2 = new Student(2,“李逵”,‘男’,“猪肉铺”,“ACT”);
s2.study();
s2.eat(10);
System.out.println(s2.sleep());
s2.show();
}
}

练习题 : 面向对象练习：设计学校开学招待设计案例

需求：
身份：老师学生学生家长
吃饭：教师食堂食堂招待所
住宿：学校公寓宿舍招待所

1.创建父接口，描述人这一类事物

package cn.tedu.review;

//1.定义一个接口，描述人这一类事物
public interface Person {
//面向接口编程，设计出老师学生学生家长的共同行为
//好处：方便接口的实现类实现时统一标准，而且更加灵活

//2.设计出共同的功能
void eat();
void sleep();
}

2.创建老师类

package cn.tedu.review;

//3.定义一个老师类实现Person接口
public class Teacher implements Person{
//4.添加Person接口中未实现的方法，并按照老师的功能来实现
@Override
public void eat() {
System.out.println(“老师在教师食堂吃饭”);
}
@Override
public void sleep() {
System.out.println(“老师在学校公寓住宿”);
}
}

3.创建学生类

package cn.tedu.review;
//5.定义一个学生类实现Person接口
public class Student implements Person{
//4.添加Person接口中未实现的方法，并按照学生的功能来实现
@Override
public void eat() {
System.out.println(“学生在学校食堂吃饭”);
}
@Override
public void sleep() {
System.out.println(“学生回学校宿舍睡觉”);
}
}

4.创建家长类

package cn.tedu.review;
//7.定义一个家长类实现Person接口
public class Parents implements Person{
//8.添加Person接口中未实现的方法，并按照家长学生的功能来实现
@Override
public void eat() {
System.out.println(“家长在招待所的饭馆吃饭~”);
}

@Override
public void sleep() {
System.out.println(“家长会招待所休息~”);
}
}

5.创建测试类

package cn.tedu.review;
/*本类用来测试学校开学招待案例*/
//9.创建测试类
public class TestPerson {
public static void main(String[] args) {
//10.在main()中创建3个类的对象
Teacher t = new Teacher();
Student s = new Student();
Parents p = new Parents();
//11.通过对象使用功能
t.eat();
t.sleep();
s.eat();
s.sleep();
p.eat();
p.sleep();
}
}

练习题 : 面向对象练习：设置小动物类，包含会飞的动物鸟类昆虫

前提：如果有两个及两个以上的类拥有相同的方法，但是实现的功能不同
就可以向上形成一个接口，这样每次实现类就可以直接添加接口中未实现的方法
需求：

鸟与昆虫具有飞行的共同功能，就可以定义一个父接口FlyAnimal，描述飞行
定义父类小鸟类Bird : 腿的数量为2 ，下蛋数量可以自定义，还有下蛋的功能
定义父类昆虫类Insect : 腿的数量为6，产卵的数量可以自定义，还有产卵的功能
定义子级鸽子类Pigeon：它既会飞，也会下蛋
定义子级燕子类Swallow：它既会飞，也会下蛋,还有自己的特有功能筑巢
定义子级蚂蚁类Ant：它既会飞，也会产卵
定义子级蜜蜂类Bee：它既会飞，也会产卵,还有自己的特有功能制作蜂蜜
创建父级接口FlyAnimal

/*定义一个接口，描述动物会飞这一功能*/
//1.定义父接口，并定义接口中飞行的功能
public interface FlyAnimal {
void fly();
}

2.创建父级抽象类Bird小鸟类

package cn.cxy.exec;

//5.定义抽象父类-小鸟类
abstract public class Bird {
//6.1 定义小鸟类中腿的数量为：2
int legNumbers = 2;
//6.2 定义小鸟类中产卵的成员变量，没有默认值
int eggNumber;

//7.定义小鸟类中下蛋的功能
public abstract void layEggs();
}

3.创建父级抽象类Insect昆虫类

package cn.cxy.exec;

//2.定义抽象父类-定义昆虫类
abstract public class Insect {
//3.1 定义昆虫类中腿的数量为：6
int legNumbers = 6;
//3.2 定义昆虫类中产卵的成员变量，没有默认值
int eggNumber;

//4.定义昆虫类中产卵的功能
public abstract void spawn();
}

4.创建子级鸽子类Pigeon：它既会飞，也会下蛋

package cn.cxy.exec;
//10.定义鸽子类-子实现类
public class Pigeon extends Bird implements FlyAnimal{
@Override//这是父抽象类中的抽象方法
public void layEggs() {
System.out.println(“鸽子的下蛋数为：”+eggNumber);
}

@Override//这是父接口中的抽象方法
public void fly() {
System.out.println(“鸽子要飞啦”);
}
}

5.创建子级燕子类Swallow：它既会飞，也会下蛋,还有自己的特有功能筑巢

package cn.cxy.exec;
//11.定义燕子类-子实现类
public class Swallow extends Bird implements FlyAnimal{
@Override//这是父抽象类中的抽象方法
public void layEggs() {
System.out.println(“燕子的下蛋数为：”+eggNumber);
}

@Override//这是父接口中的抽象方法
public void fly() {
System.out.println(“燕子归巢~”);
}

public void makeNest(){//这是子类的特有功能
System.out.println(“燕子在筑巢~”);
}
}

6.定义子级蚂蚁类Ant：它既会飞，也会产卵

package cn.cxy.exec;
//8.定义蚂蚁类-子实现类
public class Ant extends Insect implements FlyAnimal{
//9.添加父级中未实现的方法
@Override
public void fly() {//这是父接口中的抽象方法
System.out.println(“蚂蚁飞啦~”);
}
@Override
public void spawn() {//这是父抽象类中的抽象方法
System.out.println(“蚂蚁的产卵数为：”+eggNumber);
}
}

定义子级蜜蜂类Bee：它既会飞，也会产卵,还有自己的特有功能制作蜂蜜

package cn.cxy.exec;
//12.定义蚂蚁类-子实现类
public class Bee extends Insect implements FlyAnimal{
//添加父级中未实现的方法
@Override
public void fly() {//这是父接口中的抽象方法
System.out.println(“蜜蜂飞啦~”);
}
@Override
public void spawn() {//这是父抽象类中的抽象方法
System.out.println(“蜜蜂的产卵数为：”+eggNumber);
}
public void makeHoney(){//这是子类的特有功能
System.out.println(“蜜蜂在产蜂蜜~”);
}
}

8.创建测试类TestAnimals测试所有的子类

package cn.cxy.exec;
/*本类用作动物设计案例的测试类*/
public class TestAnimals {
public static void main(String[] args) {
System.out.println(“*********我在测试蚂蚁类**********”);
//1.1创建蚂蚁类对象
Ant a = new Ant();
//1.2设置产卵的数量
a.eggNumber = 300;
//1.3查看腿的条数–父类中的默认值，没有修改，直接获取
System.out.println(“蚂蚁的腿有”+a.legNumbers+“条”);
//1.4 调用实现后的功能飞行产卵
a.fly();
a.spawn();
System.out.println(“*********我在测试鸽子类**********”);
//2.1创建鸽子类对象
Pigeon p = new Pigeon();
//2.2设置下蛋的数量
p.eggNumber = 3;
//2.3查看腿的条数–父类中的默认值，没有修改，直接获取
System.out.println(“鸽子的腿有”+p.legNumbers+“条”);
//2.4 调用实现后的功能飞行下蛋
p.fly();
p.layEggs();
System.out.println(“*********我在测试燕子类**********”);
//3.1创建燕子类对象
Swallow s = new Swallow();
//3.2设置下蛋的数量
s.eggNumber = 6;
//3.3查看腿的条数–父类中的默认值，没有修改，直接获取
System.out.println(“燕子的腿有”+s.legNumbers+“条”);
//3.4 调用实现后的功能飞行下蛋
s.fly();
s.layEggs();
//3.5调用子类的特有功能–筑巢
s.makeNest();
System.out.println(“*********我在测试蜜蜂类**********”);
//4.1创建蜜蜂类对象
Bee b = new Bee();
//4.2设置产卵的数量
b.eggNumber = 600;
//4.3查看腿的条数–父类中的默认值，没有修改，直接获取
System.out.println(“蜜蜂的腿有”+b.legNumbers+“条”);
//4.4 调用实现后的功能飞行产卵
b.fly();
b.spawn();
//4.5调用子类的特有功能–产蜂蜜
b.makeHoney();
}
}

最终的执行效果：
在这里插入图片描述

练习题 : 实现二分法查找/折半查找

注意：折半查找的前提：数据必须是有序的

package cn.cxy.exec;

import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;

public class BinarySearch {
public static void main(String[] args) {
//从方法，获取一个乱序数组
int[] a = suiJi();
//对a数组排序
Arrays.sort(a);//优化的快速排序
System.out.println(Arrays.toString(a));
while(true) {
System.out.print(“查找的目标值：”);
int t = new Scanner(System.in).nextInt();
//二分法查找，
//从a数组中，查找t的位置
int index = binarySearch(a, t);
System.out.println(index);
}
}

private static int[] suiJi() {
//随机产生5+ [0,6)范围整数n
int n = 5+ new Random().nextInt(6);
//新建int[]数组，长度n
//再存到变量a
int[] a = new int[n];
//遍历数组，填入100内随机整数
for (int i = 0; i < a.length; i++) {
a[i] = new Random().nextInt(100);
}
//返回数组a
return a;
}

private static int binarySearch(int[] a, int t) {
/*
* t = 36
* mid
* [16, 21, 30, 36, 39, 70, 70, 92]
* lo
* hi
* *) lo和hi关系 lo<=hi
* *) 交叉就是找不到数据
* *) lo位置是插入点位置
*
* *)定义三个下标值
* lo=0, hi=a.length-1
* mid 只定义先不赋值
* *)循环，当lo<=hi
* *)计算中间下表存到 mid
* *)如果a[mid]<t，lo定位到mid+1
* *)否则如果a[mid]>t，hi定义到mid-1
* *)否则，返回mid的值
* *)lo、hi交叉结束
* 返回 -(lo+1)，表示-(插入点+1)
*/
int lo = 0;
int hi = a.length-1;
int mid;
while(lo <= hi) {
mid = (lo+hi) / 2;
if(a[mid] < t) {
lo = mid+1;
} else if(a[mid] > t) {
hi = mid-1;
} else {
return mid;
}
}
//避免lo是0，加1后，再加负号
return -(lo+1); // -(插入点+1)
}
}

练习题 : 二分法实现数据动态插入

注意：折半查找的前提：数据必须是有序的

package cn.cxy.exec;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;
import java.util.Scanner;

public class BinaryInsert {
public static void main(String[] args) {
/*
* 集合、泛型，都不支持基本类型
* 用基本类型的包装类
*/
ArrayList list = new ArrayList<>();
System.out.println(“回车继续”);
while(true) {
new Scanner(System.in).nextLine();
int n = new Random().nextInt(100);
//二分法查找，在list中找n所在的位置
//找不到，返回 -(插入点+1)
int index = Collections.binarySearch(list, n);
if(index < 0) {
index = (-index)-1;
}
list.add(index, n);
System.out.println(list.toString());
}
}
}

练习题 : 求数字阶乘(递归解法版)

需求:接收用户输入的数字,计算该数字的阶乘结果
已知:负数不可以有阶乘,0的阶乘结果是1,
5 ! = 5 x 4 x 3 x 2 x 1

package cn.cxy.design;
//需求:求用户输入数字的阶乘结果
//f(int n)–用来求阶乘
//规律：
//f(n)= n*f(n-1)
//f(5)= 5*4*3*2*1 = 5*f(4)
//f(4)= 4*3*2*1 = 4*f(3)
//f(3)= 3*2*1 = 3*f(2)
//f(2)= 2*1 = 2*f(1)
//f(1)= 1
//
//5!=5*4*3*2*1=120
//4!=4*3*2*1
//3!=3*2*1
//2!=2*1
//1!=1

public class TestRecursion {
public static void main(String[] args) {
int result = f(15);//调用f()用来求阶乘
System.out.println(result);
}
/**递归的两要素 1.总结规律 2.最简问题*/
public static int f(int n) {
if(n == 1) {//最简问题
return 1;
}else {//其他情况 n*f(n-1)
//递归:再方法内部自己调用自己
return n*f(n-1);
}
}
}

在这里插入图片描述

练习题 : 递归求目录总大小

需求:递归求目录的总大小 D:\ready,步骤分析如下:
1.列出文件夹中的所有资源–listFiles()–>File[]
2.判断,当前资源是文件还是文件夹–文件夹大小为0,文件大小需要累加
–是文件,求文件的字节量大小length(),累加就行
–是文件夹,继续列出文件夹下的所有资源–listFiles()–>File[]
–判断,是文件,求文件的字节量大小length(),累加就行
–判断,是文件夹,再一次列出文件夹下的所有资源
–…重复操作
也就是说,规律就是:只要是文件夹,就需要重复步骤1 2

package cn.cxy.file;

import java.io.File;

/**本类用来递归求目录总大小*/
public class FileSumRecursion {
public static void main(String[] args) {
//1.指定要求哪个目录的总大小
/**注意:此处指定的目录必须是真实存在的
* 如果传一个不存在的文件夹会报错,如果是传了一个空文件夹,大小为0*/
File file = new File(“D:\ready”);
//2.调用size()求目录大小
long total = size(file);
//3.接收结果并打印
System.out.println(“文件夹的总大小为:”+total);
}

private static long size(File file) {
//1.列出文件夹中的所有资源–listFiles()–>File[]
File[] fs = file.listFiles();

//2.遍历数组,获取每file对象
//2.1定义变量,记录总和
long sum = 0;
for(int i = 0;i < fs.length ; i++) {
//2.2通过下标操作当前遍历到的资源
File f = fs[i];
//2.3判断,当前资源是文件还是文件夹–文件夹大小为0,文件大小需要累加
if(f.isFile()) {
//–是文件,求文件的字节量大小length(),累加就行
sum += f.length();//相当于:sum = sum + f.length();
}else if(f.isDirectory()) {
//–是文件夹,继续列出文件夹下的所有资源,1 2步骤–listFiles()–>File[]
/**方法的递归,递归现象,就是在方法的内部调用方法自身*/
sum += size(f);
}
}
return sum;//把sum记录的值返回调用位置
}
}

练习题 : 递归删除文件夹

需求:递归删除文件夹 D:\ready\a
1.列出文件夹下的所有资源listFiles()
2.判断,当前资源是文件还是文件夹
–判断,是文件,直接删除delete()
–判断,是文件夹,继续重复操作1 2
具体思路可以分为这么几步:
1.首先,我们需要指定一个根目录作为要删除的对象
2.列出文件夹下的所有资源listFiles(),并进行遍历
3.判断当前的资源,如果是文件,直接删除;如果是文件夹,则执行步骤2
4.将文件夹中的内容删除完毕后,删除文件夹本身

package cn.tedu.file;

import java.io.File;

/**本类用于递归删除目录*/
public class TestFileDeleteRecursion {
public static void main(String[] args) {
//1.指定要删除的目录
/**为了更好的测试,注意指定的目录是已存在的目录,但是,千万不要删盘符!!!*/
/*我们也有一些没有权限的文件夹,那个是无法访问且不能删除的哦*/
File file = new File(“D:\ready\a”);
//2.调用删除目录的方法
boolean result = del(file);
//3.打印删除的结果
System.out.println(“删除的结果为:”+result);
}

public static boolean del(File file) {//完成的同学不是很多,抓紧时间写,写完截图发群里哈,这首歌结束我们继续
//1.列出文件夹下的所有资源
File[] fs = file.listFiles();
//2.循环遍历拿到的所有资源
for (int i = 0; i < fs.length; i++) {
//2.1获取本次循环遍历到的file对象
File f = fs[i];
//3.判断,当前资源是文件还是文件夹
if(f.isFile()) {
f.delete();//是文件,直接删除
System.out.println(file.getName()+“文件删除成功!”);
}else if(f.isDirectory()) {
//是文件夹,需要继续进行步骤1 2 ,出现了重复调用的情况
//递归,在方法的内部调用自己
del(f);
}
}
//位置:在for循环执行之外删除文件夹
file.delete();//空文件夹直接删除
System.out.println(file.getName()+“文件夹删除成功!”);
return true;
}
}

练习题 : 复制文件(字节流批量读取)

需求:接收用户目标文件的路径,复制目标文件到指定路径

import java.io.*;
import java.util.Scanner;

public class TestCopyFiles {
public static void main(String[] args) {
//1.提示并接收用户输入的要复制的源文件路径–复制啥
System.out.println(“请输入源文件路径:”);
String f = new Scanner(System.in).nextLine();

//2.提示并接收用户输入的目标文件所在的位置–复制到哪
System.out.println(“请输入目标文件的路径:”);
String t = new Scanner(System.in).nextLine();

//3.1根据源文件路径封装from文件对象
File from = new File(f);
//3.2根据目标文件路径封装to文件对象
File to = new File(t);
//3.3根据用户提供的路径完成文件的复制操作
copy(from,to);
}

public static void copy(File from, File to) {
InputStream in = null;//定义在整个方法中都生效的字节输入流对象,注意是局部变量,需要初始化,对象的默认值是null
OutputStream out = null;//定义在整个方法中都生效的字节输出流对象,注意是局部变量,需要初始化,对象的默认值是null
try {
//1.读取from文件–操作文件的是字节输入流
in = new BufferedInputStream(new FileInputStream(from));
//2.写出到to文件–操作文件的是字节输出流
out = new BufferedOutputStream(new FileOutputStream(to));

//3.边读边写
int b = 0;//定义变量b,记录读取到的数据
/**需求:想要实现批量读取,使用的是read(byte[] b)重载的形式,可以按照数组的方式来读 */
/**可以自定义数组,长度建议与源码保持一致,8*1024 = 8192*/
byte[] bs = new byte[8*1024];
while( (b=in.read(bs)) != -1 ) {//只有没有数据时,才返回-1,跳出循环,读写结束
out.write(bs);//将读到的数据写出到文件
}
System.out.println(“恭喜您!文件复制成功!”);
} catch (IOException e) {
System.out.println(“很抱歉!文件复制失败!”);
e.printStackTrace();//打印错误信息
}finally {
//释放资源
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

练习题 : 逆序遍历List集合

手写一个程序，完成List集合对象的逆序遍历

package cn.cxy.exec;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

/**本类用于进一步测试List接口*/
public class TestList {
public static void main(String[] args) {
//1.创建List接口的多态对象
List list = new ArrayList<>();
//2.向创建好list集合添加元素
list.add(“喜羊羊”);
list.add(“美羊羊”);
list.add(“懒羊羊”);
list.add(“沸羊羊”);
list.add(“小肥羊”);
list.add(“肥羊卷”);
System.out.println(list);
System.out.println(“listIterator的逆序遍历：”);
ListIterator it3 = list.listIterator();
while(it3.hasNext()){//判断是否有下一个元素可迭代
System.out.println(it3.next());//打印当前迭代到的元素
if(!it3.hasNext()){//直到迭代器没有下一个元素可迭代–到最后了
System.out.println(“开始逆序迭代：”);
while (it3.hasPrevious()){//判断是否有上一个元素可迭代
System.out.println(it3.previous());//打印获取到的上一个元素
}
break;//终止循环，不然会一直从头到尾，再从尾到头迭代
}
}
}

}

练习题 : 回文问题

需求,如果一个用户输入的数据,从前到后或者从后到前读到的内容都是一样的,我们就称这种数据为"回文",比如123321 或者 12321 或者上海自来水来自海上等等

import java.util.Scanner;

public class TestNumber {
public static void main(String[] args) {
System.out.println(“请输入一个字符串:”);
String s = new Scanner(System.in).nextLine();

if(!stringJudge(s)){
System.out.println(s + “不是回文字符串”);
}else{
System.out.println(s + “是回文字符串”);
}
//调用第二个方法解决
stringJudge2(s);
}

//判断字符串是否回文
private static boolean stringJudge(String str) {
for (int i = 0; i < str.length() - i - 1; i++){
if(str.charAt(i) == str.charAt(str.length() - i - 1)){
continue;
}else{
return false;
}
}

return true;
}
//判断字符串是否回文2
private static void stringJudge2(String s) {
//方法2:将字符串反转比较
String s2 = new StringBuffer(s).reverse().toString();
if(s.compareTo(s2) == 0){
System.out.println(s + “是回文字符串”);
}else{
System.out.println(s + “不是回文字符串”);
}
}
}

练习题 : 手写数组列表

手写一个数组列表，实现基本的数据操作功能
数组列表类：

package cn.cxy.exec;

import java.util.Arrays;

写在最后

作为一名即将求职的程序员，面对一个可能跟近些年非常不同的 2019 年，你的就业机会和风口会出现在哪里？在这种新环境下，工作应该选择大厂还是小公司？已有几年工作经验的老兵，又应该如何保持和提升自身竞争力，转被动为主动？

就目前大环境来看，跳槽成功的难度比往年高很多。一个明显的感受：今年的面试，无论一面还是二面，都很考验Java程序员的技术功底。

最近我整理了一份复习用的面试题及面试高频的考点题及技术点梳理成一份“Java经典面试问题（含答案解析）.pdf和一份网上搜集的“Java程序员面试笔试真题库.pdf”（实际上比预期多花了不少精力），包含分布式架构、高可扩展、高性能、高并发、Jvm性能调优、Spring，MyBatis，Nginx源码分析，Redis，ActiveMQ、Mycat、Netty、Kafka、Mysql、Zookeeper、Tomcat、Docker、Dubbo、Nginx等多个知识点高级进阶干货！

由于篇幅有限，为了方便大家观看，这里以图片的形式给大家展示部分的目录和答案截图！
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传