我敢说这是全网最详细的基础讲解，附源码实例，没人学不明白

之前有粉丝后台跟我说，作为一个初学者，真的是不清楚该如何去进行学习，直接上ssm框架也看不明白，那我作为这么一个宠粉的人，怎么可能让粉丝有这样的顾虑啊，今天真的是基础到极点了，分享我这边的相应的一些代码实例，因为在代码的备注中已经写的很清楚了，所以基本不会再通过文字进行讲解

文章首发公众号：Java架构师联盟，每日更新技术好文，后面也会开源我的代码仓库，毕竟现在还比较单薄

注释+源码+结果，这边应该展示的很清楚，也比较好理解，不过，一定要自己去实践一下，不实践再简单的技术理解起来也不容易

我敢说这是全网最详细的基础讲解，附源码实例，没人学不明白

而向多线程什么的学习实例，我这边之前的文章也整理过，大家可以去查看，每一个都带着相应的源码展示

好了，话不多说，看正题

Java基础之：OOP——抽象类

package com.biws.testabstract;
 ​
 /**
 
 
 
  
@author ：biws
 
  
@date ：Created in 2020/12/22 21:14
 
  
@description：抽象类测试
 */
 public class Abstract_Test {
 ​
 public static void main(String[] args) {
 ​
 Cat cat = new Cat("小花猫");
 cat.eat();
 }
 ​
 }
 ​
 ​
 abstract class Animal { //抽象类
 private String name;
 ​
 public Animal(String name) {
 super();
 this.name = name;
 }
 ​
 public String getName() {
 return name;
 }
 ​
 public void setName(String name) {
 this.name = name;
 }
 ​
 //eat , 抽象方法
 public abstract void eat();
 }
 ​
 //解读
 //1. 当一个类继承了抽象类,就要把抽象类的所有抽象方法实现
 //2. 所谓方法实现，指的是 把方法体写出, 方法体是空，也可以.
 class Cat extends Animal {
 public Cat(String name) {
 super(name);
 // TODO Auto-generated constructor stub
 }
 ​
 public void eat() {
 System.out.println(getName() + " 爱吃 <・)))><<");
 }
 }

然后呢，我们看一下多态的实现

package com.biws.testabstract;
 ​
 /**
 
 
 
  
@author ：biws
 
  
@date ：Created in 2020/12/22 21:17
 
  
@description：多态在抽象类中的实现
 */
 public class AbstractPolArray {
 ​
 public static void main(String[] args) {
 //抽象类不可以实例化，但可以使用多态数组
 Animal1[] animal1 = new Animal1[2];
 ​
 animal1[0] = new Dog1("小黑狗");
 animal1[1] = new Cat1("小花猫");
 ​
 //多态数组的使用
 for (int i = 0; i < animal1.length; i++) {
 show(animal1[i]);
 }
 }
 ​
 //这里不用担心会传入一个Animal类型的实例，因为Animal不能实例化
 //编译器不会通过，所以只会传入Animal的子类实例
 public static void show(Animal1 a) {
 a.eat(); //多态的使用
 ​
 if(a instanceof Dog1) {
 ((Dog1)a).watch();
 }else if(a instanceof Cat1) {
 ((Cat1)a).catchMouse();
 }
 }
 }
 ​
 abstract class Animal1{
 private String name;
 ​
 public Animal1(String name) {
 super();
 this.name = name;
 }
 ​
 public String getName() {
 return name;
 }
 ​
 public void setName(String name) {
 this.name = name;
 }
 ​
 //动物都有eat的动作，但我们并不知道每一个动物具体怎么样eat
 //所以这里通过抽象提供了eat方法，需要子类来实现
 public abstract void eat();
 }
 ​
 class Dog1 extends Animal1{
 public Dog1(String name) {
 super(name);
 }
 ​
 @Override
 public void eat() {
 System.out.println(getName() + "啃骨头......");
 }
 ​
 public void watch() {
 System.out.println(getName() + "守家.....");
 }
 }
 ​
 class Cat1 extends Animal1{
 public Cat1(String name) {
 super(name);
 }
 ​
 @Override
 public void eat() {
 System.out.println(getName() + "吃鱼......");
 }
 ​
 public void catchMouse(){
 System.out.println(getName() + "抓老鼠.....");
 }
 }

最后举个小例子总结一下

package com.biws.testabstract;
 ​
 /**
 
 
 
  
@author ：biws
 
  
@date ：Created in 2020/12/22 21:24
 
  
@description：模板设计模式
 */
 public class Abstract_Template {
 public static void main(String[] args) {
 Template sub = new Sub();
 sub.caleTimes(); //实际是调用了Template中的caleTimes方法
 ​
 Template subStringB = new SubStringB();
 subStringB.caleTimes();
 ​
 //这里可以看到 StringBuffer在拼接字符串时，远远优于String拼接的效率
 }
 }
 ​
 abstract class Template{ //抽象类
 public abstract void code(); //抽象方法
 public void caleTimes(){ // 统计耗时多久是确定
 //统计当前时间距离 1970-1-1 0:0:0 的时间差，单位ms
 long start = System.currentTimeMillis();
 code(); //这里的code在调用时，就是指向子类中已经重写实现了的code
 long end = System.currentTimeMillis();
 System.out.println("耗时："+(end-start));
 }
 }
 ​
 class Sub extends Template{
 ​
 @Override
 public void code() {
 String x = "";
 for(int i = 0;i < 10000 ; i++) { //拼接1W个hello 看处理时间
 x += "hello" + i;
 }
 }
 }
 ​
 class SubStringB extends Template{
 @Override
 public void code() {
 StringBuffer stringBuffer = new StringBuffer();
 for(int i = 0;i < 10000 ; i++) { //拼接1W个hello 看处理时间
 stringBuffer.append("hello" + i);
 }
 }
 }

Java基础之：StringBuffer与StringBuilder

简单直白点，直接一套代码走起

package com.biws.string;
 ​
 /**
 
 
 
  
@author ：biws
 
  
@date ：Created in 2020/12/22 21:27
 
  
@description：String_StringBuffer_StringBuilder对比
 */
 public class String_StringBuffer_StringBuilder {
 public static void main(String[] args) {
 // TODO Auto-generated method stub
 ​
 String text = ""; //字符串
 long startTime = 0L;
 long endTime = 0L;
 StringBuffer buffer = new StringBuffer("");//StringBuffer
 StringBuilder builder = new StringBuilder("");//StringBuilder
 ​
 startTime = System.currentTimeMillis();
 for (int i = 0; i < 80000; i++) {
 buffer.append(String.valueOf(i));
 }
 endTime = System.currentTimeMillis();
 System.out.println("StringBuffer的执行时间：" + (endTime - startTime));
 ​
 ​
 ​
 startTime = System.currentTimeMillis();
 for (int i = 0; i < 80000; i++) {
 builder.append(String.valueOf(i));
 }
 endTime = System.currentTimeMillis();
 System.out.println("StringBuilder的执行时间：" + (endTime - startTime));
 ​
 ​
 ​
 startTime = System.currentTimeMillis();
 for (int i = 0; i < 80000; i++) {
 text = text + i;
 }
 endTime = System.currentTimeMillis();
 System.out.println("String的执行时间：" + (endTime - startTime));
 ​
 }
 }

查看一下执行结果

我敢说这是全网最详细的基础讲解，附源码实例，没人学不明白

Java基础之：Math & Arrays

Math

简单粗暴，直接进行代码展示

package com.biws.testmath;
 ​
 /**
 
 
 
  
@author ：biws
 
  
@date ：Created in 2020/12/22 21:42
 
  
@description：测试math类
 /
 public class ClassTest {
 public static void main(String[] args) {
 //1.abs 绝对值
 int abs = Math.abs(9);
 System.out.println(abs);
 //2.pow 求幂
 double pow = Math.pow(-3.5, 4);
 System.out.println(pow);
 //3.ceil 向上取整,返回>=该参数的最小整数;
 double ceil = Math.ceil(-3.0001);
 System.out.println(ceil);
 //4.floor 向下取整，返回<=该参数的最大整数
 double floor = Math.floor(-4.999);
 System.out.println(floor);
 //5.round 四舍五入 Math.floor(该参数+0.5)
 long round = Math.round(-5.001);
 System.out.println(round);
 //6.sqrt 求开方
 double sqrt = Math.sqrt(-9.0);
 System.out.println(sqrt);
 //7.random 返回随机数【0——1)
 //[a-b]:int num = (int)(Math.random()（b-a+1）+a)
 double random = Math.random();
 System.out.println(random);
 ​
 //小技巧：获取一个 a-b 之间的一个随机整数
 int a = (int)(Math.random()(15-7+1)+7);
 System.out.println(a);
 / 
 
  
理解：
 
  
1.Math.random() 是 [0，1)的随机数
 
  
2.(Math.random()*(15-7+1) 就是[0，9)
 
  
3.Math.random()*(15-7+1)+7 就是[7，16)
 
  
4.(int)取整就是 [7,15] ，即[a,b]之间的随机整数
 */
 }
 }

执行结果

我敢说这是全网最详细的基础讲解，附源码实例，没人学不明白

Arrays

正常的执行

package com.biws.testarray;
 ​
 import java.util.Arrays;
 import java.util.Comparator;
 ​
 /**
 
 
 
  
@author ：biws
 
  
@date ：Created in 2020/12/22 21:44
 
  
@description：Array中常用排序方法
 */
 public class TestArray1 {
 public static void main(String[] args) {
 Integer[] arr = { 25, 35, 11, 32, 98, 22 };
 // Arrays.sort(arr); //默认小到大排序
 System.out.println(Arrays.toString(arr));
 ​
 // 使用匿名内部类重写compare方法，实现从大到小排序
 Arrays.sort(arr, new Comparator() {
 ​
 @Override
 public int compare(Integer o1, Integer o2) {
 if (o1 > o2) {
 return -1;
 } else if (o1 < o2) {
 return 1;
 } else {
 return 0;
 }
 }
 });
 System.out.println(Arrays.toString(arr));
 }
 }

结果查看

我敢说这是全网最详细的基础讲解，附源码实例，没人学不明白

重写之后的执行结果

package com.biws.testarray;
 ​
 import java.util.Arrays;
 import java.util.Comparator;
 ​
 /**
 
 
 
  
@author ：biws
 
  
@date ：Created in 2020/12/22 21:46
 
  
@description：重写array中的排序方法
 */
 public class overwriteArraySort {
 @SuppressWarnings("unchecked")
 public static void sort(Integer[] arr, Comparator c) {
 Integer temp = 0;// 自动装箱
 for (int i = 0; i < arr.length; i++) {
 for (int j = 0; j < arr.length - 1 - i; j++) {
 if (c.compare(arr[j] , arr[j + 1]) > 0) {
 temp = arr[j];
 arr[j] = arr[j + 1];
 arr[j + 1] = temp;
 }
 }
 }
 }
 ​
 public static void main(String[] args) {
 Integer[] arr = { 35, 25, 11, 32, 98, 22 };
 // MyArrays.sort(arr);//不添加 Comparator接口对象为参数，就是简单的冒泡排序方法
 System.out.println(Arrays.toString(arr));
 //添加匿名内部类对象为参数，就可以改变排序方式。用此方法可以很灵活的使用排序。
 overwriteArraySort.sort(arr, new Comparator() {
 ​
 @Override
 public int compare(Integer o1, Integer o2) {
 //通过返回值的正负来控制，升序还是降序
 //只有当返回值为1时，才会发生交换。例如这里，o1 < o2时返回1 ，进行交换
 //也就是需要前面的数，比后面的数大，即降序
 if (o1 < o2) {
 return -1;
 } else if (o1 > o2) {
 return 1;
 } else {
 return 0;
 }
 }
 });
 System.out.println(Arrays.toString(arr));
 }
 ​
 }

结果

我敢说这是全网最详细的基础讲解，附源码实例，没人学不明白

Java基础之：大数

package com.biws.bignum;
 ​
 import java.math.BigDecimal;
 import java.math.BigInteger;
 ​
 /**
 
 
 
  
@author ：biws
 
  
@date ：Created in 2020/12/22 22:03
 
  
@description：
 */
 public class test {
 public static void main(String[] args) {
 BigInteger i1 = new BigInteger("1234567890");
 BigInteger i2 = new BigInteger("200");
 // 2.调用常见的运算方法
 // System.out.println(b1+b2); 不能使用 这样的 + 方法运行
 // 并且，add 这些方法只能是大数于大数相加，BigInteger.add(BigInteger);
 System.out.println(i1.add(i2));// 加
 System.out.println(i1.subtract(i2));// 减
 System.out.println(i1.multiply(i2));// 乘
 System.out.println(i1.divide(i2));// 除
 ​
 BigDecimal b1 = new BigDecimal("1234567890.567");
 BigDecimal b2 = new BigDecimal("123");
 // 2.调用常见的运算方法
 // System.out.println(b1+b2); 不能使用 + 号运算..
 // 并且，add 这些方法只能是大数于大数相加，BigDecimal.add(BigDecimal);
 System.out.println(b1.add(b2));// 加
 System.out.println(b1.subtract(b2));// 减
 System.out.println(b1.multiply(b2));// 乘
 //后面这个 BigDecimal.ROUND_CEILING 需要指定，是精度
 //没有这个参数，则会提示:错误
 System.out.println(b1.divide(b2, BigDecimal.ROUND_CEILING));// 除
 }
 }

查看一下结果

我敢说这是全网最详细的基础讲解，附源码实例，没人学不明白

Java基础之：日期类

日期类中所包含的方法有点多，所以在这里我用junit方法进行测试，那是真的香 啊，节省了大量的代码编写时间

package com.biws.TestDate;
 ​
 import org.junit.jupiter.api.Test;
 ​
 import java.time.;
 import java.time.format.DateTimeFormatter;
 import java.time.temporal.ChronoUnit;
 import java.util.Date;
 ​
 /*
 
 
 
  
@author ：biws
 
  
@date ：Created in 2020/12/22 22:06
 
  
@description：测试全部date类方法
 */
 public class allDateFunction {
 public static void main(String[] args) {
 // TODO Auto-generated method stub
 new allDateFunction().hi();
 new allDateFunction().hello();
 }
 ​
 // JUnit 测试单元
 // 1. 配置快捷键 alt + J
 // 2. 如果要运行某个 测试单元，就选中方法名或光标定位在方法名，在运行 Junit
 // 3. 如果不选，就运行，就把所有的测试单元都运行
 // 4.@Test,代表此方法是测试单元，可以单独运行测试
 ​
 ​
 @Test
 public void hi() {
 System.out.println("hi ");
 }
 ​
 @Test
 public void hello() {
 System.out.println("hello");
 }
 ​
 @Test
 public void testLocalDate() {
 // 获取当前日期（只包含日期，不包含时间）
 LocalDate date = LocalDate.now();
 System.out.println(date);
 ​
 // 获取日期的指定部分
 System.out.println("year:" + date.getYear());
 System.out.println("month:" + date.getMonth());
 System.out.println("day:" + date.getDayOfMonth());
 System.out.println("week:" + date.getDayOfWeek());
 ​
 // 根据指定的日期参数，创建LocalDate对象
 LocalDate of = LocalDate.of(2010, 3, 2);
 System.out.println(of);
 ​
 }
 ​
 // 测试LocalTime类
 @Test
 public void testLocalTime() {
 // 获取当前时间（只包含时间，不包含日期）
 LocalTime time = LocalTime.now();
 System.out.println(time);
 ​
 // 获取时间的指定部分
 System.out.println("hour:" + time.getHour());
 System.out.println("minute:" + time.getMinute());
 ​
 System.out.println("second:" + time.getSecond());
 System.out.println("nano:" + time.getNano());
 ​
 // 根据指定的时间参数，创建LocalTime对象
 LocalTime of = LocalTime.of(10, 20, 55);
 System.out.println(of);
 ​
 }
 ​
 // 测试LocalDateTime类
 ​
 @Test
 public void testLocalDateTime() { // 获取当前时间（包含时间+日期）
 ​
 LocalDateTime time = LocalDateTime.now();
 ​
 // 获取时间的指定部分 System.out.println("year:" + time.getYear());
 System.out.println("month:" + time.getMonthValue());
 System.out.println("day:" + time.getMonth());
 System.out.println("day:" + time.getDayOfMonth());
 System.out.println("hour:" + time.getHour());
 System.out.println("minute:" + time.getMinute());
 ​
 System.out.println("second:" + time.getSecond());
 System.out.println("nano:" + time.getNano());
 ​
 // 根据指定的时间参数，创建LocalTime对象
 LocalDateTime of = LocalDateTime.of(2020, 2, 2, 10, 20, 55);
 System.out.println(of);
 ​
 }
 ​
 @Test
 public void testMonthDay() {
 ​
 LocalDate birth = LocalDate.of(1994, 7, 14); // 生日
 MonthDay birthMonthDay = MonthDay.of(birth.getMonthValue(), birth.getDayOfMonth());
 ​
 LocalDate now = LocalDate.now(); // 当前日期
 MonthDay current = MonthDay.from(now);
 ​
 if (birthMonthDay.equals(current)) {
 System.out.println("今天生日");
 } else {
 System.out.println("今天不生日");
 }
 ​
 }
 ​
 // 判断是否为闰年
 @Test
 public void testIsLeapYear() {
 ​
 LocalDate now = LocalDate.now();
 ​
 System.out.println(now.isLeapYear());
 ​
 }
 // 测试增加日期的某个部分
 ​
 @Test
 public void testPlusDate() {
 ​
 LocalDate now = LocalDate.now(); // 日期
 // 3年前 的日期
 LocalDate plusYears = now.plusDays(-1);
 System.out.println(plusYears);
 ​
 }
 ​
 // 使用plus方法测试增加时间的某个部分
 // 时间范围判断
 @Test
 public void testPlusTime() {
 ​
 LocalTime now = LocalTime.now();// 时间
 ​
 LocalTime plusHours = now.plusSeconds(-500);
 ​
 System.out.println(plusHours);
 ​
 }
 ​
 // 使用minus方法测试查看一年前和一年后的日期
 ​
 @Test
 public void testMinusTime() {
 LocalDate now = LocalDate.now();
 ​
 LocalDate minus = now.minus(1, ChronoUnit.YEARS);
 ​
 // LocalDate minus2 = now.minusYears(1);
 System.out.println(minus);
 ​
 }
 ​
 // 测试时间戳类：Instant ，相当于以前的Date类
 @Test
 public void testInstant() {
 Instant now = Instant.now();
 System.out.println(now);
 ​
 // 与Date类的转换
 Date date = Date.from(now);
 System.out.println(date);
 ​
 Instant instant = date.toInstant();
 ​
 System.out.println(instant);
 }
 ​
 // 格式转换
 @Test
 public void testDateTimeFormatter() {
 DateTimeFormatter pattern = DateTimeFormatter.ofPattern("MM-dd yyyy HH:mm:ss");
 ​
 // 将字符串转换成日期
 LocalDateTime parse = LocalDateTime.parse("03-03 2017 08:40:50", pattern);
 System.out.println(parse);
 ​
 // 将日期转换成字符串
 //LocalDateTime parse = LocalDateTime.now();
 ​
 String format = pattern.format(parse);
 System.out.println(format);
 }
 }