public class test01 {  
public static void main(String[] args) {   
  
int num = 100; // 使用数据类型 + 变量名可以声明变量  
double numDou = 100.01;  
  
double numDou01;  
numDou01 = 20.8;  
  
final int num2 = 10; // final 声明则后续无法修改该值，但必须添加初始值  
// 当然之后我们会提到方法以及类方面的知识，使用final修饰也就是表明该方法时最终方法，不能被重写
// 如果使用final修饰类，那就表示这是最终类，不能够被继承
  
byte num3 = 100;  
short num4 = 100;  
long num5 = 100L;  
  
float num6 = 10.8F;  
  
char text = '6';  
  
boolean stutas = false;  
boolean stutas1 = true;  
}  
}

比较运算符

public class test01 {  
public static void main(String[] args) {  
System.out.println(10 > 100);  
System.out.println(10 < 100);  
System.out.println(10 >= 100);  
System.out.println(10 <= 100);  
System.out.println(10 == 100);  
System.out.println(10 != 100);  
  
System.out.println(true && false);  
System.out.println(true && true);  
System.out.println(false && false);  
System.out.println(false && true);  
  
System.out.println(true || false);  
System.out.println(true || true);  
System.out.println(false || false);  
System.out.println(false || true);  
  
System.out.println(!true);  
System.out.println(!false);  
}  
}

条件语句

// if语句
public class test01 {  
public static void main(String[] args) {  
double num = 132.784;  
if (num > 132.784) {  
System.out.println("通过");  
} else {  
System.out.println("未通过");  
}  
// 未通过  
  
if (num > 132.784) {  
System.out.println("通过");  
} else if (num == 132.784){  
System.out.println("水平线");  
} else {  
System.out.println("未通过");  
}  
// 水平线  
}  
}

// switch 语句
public class test01 {  
public static void main(String[] args) {  
int num = 10;  
switch (num) {  
case 10:  
System.out.println("10分");  
break;  
case 0:  
System.out.println("0分");  
break;  
default:  
System.out.println("未识别");  
}  
}  
}

// 循环语句
public class test01 {  
public static void main(String[] args) {  
// for循环
for (int i = 0; i < 10; i++) {  
System.out.println(i);  
}  
  
// while 循环两种书写方式
int num = 5;  
while (num > 0) {  
System.out.println(num);  
num--;  
}  // 条件满足执行循环
  
int num01 = -1;  
do {  
System.out.println(num01);  
num01--;  
} while (num01 > 0);  
}  
} // 只打印了一次-1，因为该写法条件在后面，无论怎么样都会执行一次

引用类型-数组array

import java.util.Arrays;  
  
public class test01 {  
public static void main(String[] args) {  
// 引用类型  
  
// 数组  
int[] myArrList = {10,100,1000}; // 简化写法  
int[] myArrList1 = new int[]{10,100,1000}; // 完整写法  
  
int[] myArrList2 = new int[6]; // 6为数组长度  
  
System.out.println(myArrList1); // 输出地址：[I@4eec7777 数据存在堆内存，我们只是取出来了栈内存中的对于地址，这就是引用类型  
System.out.println(Arrays.toString(myArrList1)); // 使用java数组工具类取出：[10, 100, 1000]  
  
System.out.println(myArrList1[1]); // 100  
System.out.println(myArrList1.length); // 3  
  
// foreach循环:循环数组每一项  
for (int item:myArrList) {  
System.out.println(item);  
}  
}  
}

引用数据类型字符串string

public class test01 {  
public static void main(String[] args) {  
String str = "你好，我和char不同，我可以用双引号，可以存储大量字符";  
String str1 = new String("构造函数声明");  
System.out.println(str1.length()); // 6  
System.out.println(str + str1); // 你好，我和char不同，我可以用双引号，可以存储大量字符构造函数声明  
  
// 查找字符位置  
System.out.println(str.indexOf("char")); // 5  
// 替换字符串  
System.out.println(str1.replace("构造函数","666")); // 666声明  
// 根据指定字符分割为数组，然后通过指定字符连接  
System.out.println(str.join("&",str.split("，"))); // 你好&我和char不同&我可以用双引号&可以存储大量字符  
  
  
// 我们只是对字符串进行了拷贝，原字符串并没有被改变  
}  
}

类（对一类物体事物进行一个抽取相同属性然后归结为一个类）类的封装

我们封装一个类，可以在主函数中创建该类的实例化对象，这个对象是抽象化的实例，是一个实实在在的完整事物，实例化对象可以使用类中的方法属性，可以根据公共类来将对象实例化，实例化对象可以修改自己的属性、调用方法实现功能，形成一个完整的实例对象。

public class test01 {  
public static void main(String[] args) {  
// 创建类的实例  
testClass test = new testClass("小郭",24);  
System.out.println(test.name); // 小郭  
// System.out.println(test.hobby); // 'hobby' 在 'org.example.test.testClass' 中具有 private 访问权限  
System.out.println(test.getHobby()[0]); // 爱好1  
String[] testStringArray = {"测试","测试"};  
test.setHobby(testStringArray);  
System.out.println(test.getHobby()[0]); // 测试  
test.testFunc(); // 小郭  
}  
}  
  
// 创建一个类 class  
class testClass {  
// 类的属性  
String name = "默认名称";  
int age = 18;  
private String[] hobby = {"爱好1","爱好2"}; // private标记私有属性，外部无法修改  
String publicMessage = "公共信息";  
  
// 与类同名的构造方法 - 接受实例属性值  
public testClass (String name,int age) {  
this.name = name;  
this.age = age;  
}  
  
// 直接修改 private属性无法修改，但是可以通过方法为属性设置getter和setter函数来进行修改  
public String[] getHobby() {  
return this.hobby;  
}  
  
public void setHobby(String[] newValue) {  
this.hobby = newValue;  
}  
  
// 其他方法  
public void testFunc() {  
System.out.println(this.name);  
}  
}

类的继承

假如我们现在需要一个新的类，并且新的类需要的功能，在之前创建好的 testClass 类中已经存在了，那么我们就没必要再将功能写一遍了，可以直接进行继承

public class test01 {  
public static void main(String[] args) {  
// 创建类的实例  
testClass test = new testClass("小郭",24);  
System.out.println(test.name);  
System.out.println(test.getHobby()[0]);  
String[] testStringArray = {"测试","测试"};  
test.setHobby(testStringArray);  
System.out.println(test.getHobby()[0]);  
test.testFunc();  
}  
}  
// 创建一个类 class  
class testClass {  
// 类的属性  
String name = "默认名称";  
int age = 18;  
private String[] hobby = {"爱好1","爱好2"}; // private标记私有属性，外部无法修改  
String publicMessage = "公共信息";  
public static String other = "使用 static 修饰的变量会让使用该类创建的所有对象都可以访问该变量，同样，static也可以修饰静态方法";  
  
// 与类同名的构造方法 - 接受实例属性值  
public testClass (String name,int age) {  
this.name = name;  
this.age = age;  
}  
  
// 直接修改 private属性无法修改，但是可以通过方法为属性设置getter和setter函数来进行修改  
public String[] getHobby() {  
return this.hobby;  
}  
  
public void setHobby(String[] newValue) {  
this.hobby = newValue;  
}  
  
// 其他方法  
public void testFunc() {  
System.out.println(this.name);  
}  
}  
  
class extentClass extends testClass {  
private double height;  
  
// 而要继承属性，就需要在子类的构造方法中通过spuer调用父类的构造方法，并传入可能存在的参数  
public extentClass(String name,int age,double height) {  
super(name,age);  
this.height = height;  
}  
  
// 当我们需要给子类不同的方法功能，则需要用到多态  
// 方法一就是通过 @Override 来重写方法  
@Override  
public void testFunc() {  
System.out.println("重写后的方法");  
}  
  
// 方法二:方法重载 创建一个同名但参数不同的方法  
public void testFunc(String text) {  
System.out.println(text);  
}  
}

上面的代码我穿插了一点静态修饰的内容，为了不影响多态的整体内容展示，只是展现出 static 知识点，没有做使用，在这里做出一些解释：

使用 static 修饰的变量或者方法称为静态变量或者静态方法

抽象类

package org.example;  
  
public class Main {  
public static void main(String[] args) {  
testClass2 test = new testClass2();  
test.word(); // 重写了  
}  
}  
  
// 使用 abstract 修饰的类就是抽象类  
// 抽象类不能实例化、可以有构造方法  
// 对子类有要求：抽象类的子类要不就重写抽象类的所有抽象方法，要不就也是抽象类  
abstract class Person {  
public abstract void word();  
}  
  
abstract class testClass extends Person {  
  
}  
  
class testClass2 extends Person {  
public void word() {  
System.out.println("重写了");  
};  
}

接口

package org.example;  
  
public class Main {  
public static void main(String[] args) {  
  
}  
}  
  
// 接口不能实例化  
// 类可以去实现接口，通过 implements 来表示  
interface testInter {  
public abstract void test();  
}  
  
interface testInter02 {  
  
}  
  
interface testInter03 {  
  
}  
  
class testClass implements testInter,testInter02 {  
public void test() {  
  
}  
}  
  
class testClass02 implements testInter02 {  
  
}  
  
// 注意继承的子类，如果父类实现了接口，并且子类没有修改的需求，那么子类就不需要专门再实现一次接口方法了  
class testCLassSon extends testClass implements testInter03{  
  
}

List集合

以 ArrayList为例

List接口是一个有序的集合，它允许我们像数组一样添加和删除元素

package org.example;  
  
import java.util.List;  
import java.util.ArrayList;  
  
class Main {  
  
public static void main(String[] args) {  
//使用ArrayList类创建列表  
List numbers = new ArrayList<>();  
  
//将元素添加到列表  
numbers.add(1);  
numbers.add(2);  
numbers.add(3);  
System.out.println(numbers); // [1, 2, 3]  
  
//从列表中访问元素  
int number = numbers.get(2);  
System.out.println("访问元素: " + number); // 访问元素: 3  
  
//从列表中删除元素  
int removedNumber = numbers.remove(1);  
System.out.println("删除元素: " + removedNumber); // 删除元素: 2  
}  
}

Set集合

以 HashSet为例

Set接口允许我们将元素存储在不同的集合中，类似于数学中的集合。它不能有重复的元素。

package org.example;  
  
import java.util.Set;  
import java.util.HashSet;  
  
class Main {  
  
public static void main(String[] args) {  
//使用HashSet类创建集合  
Set set1 = new HashSet<>();  
  
//将元素添加到set1  
set1.add(2);  
set1.add(3);  
System.out.println(set1); // [2, 3]  
  
//使用HashSet类创建另一个集合  
Set set2 = new HashSet<>();  
  
//添加元素  
set2.add(1);  
set2.add(2);  
System.out.println(set2); // [1, 2]  
  
//两个集合的并集  
set2.addAll(set1);  
System.out.println(set2); // [1, 2, 3]  
}  
}

Map集合

以 HashMap为例

Map接口允许元素以键/值对的形式存储。键是唯一的名称，可用于访问map中的特定元素。而且，每个键都有一个与之关联的值

package org.example;  
  
import java.util.Map;  
import java.util.HashMap;  
  
class Main {  
  
public static void main(String[] args) {  
//使用HashMap类创建map  
Map numbers = new HashMap<>();  
  
//将元素插入map集合  
numbers.put("One", 1);  
numbers.put("Two", 2);  
System.out.println("Map: " + numbers); // Map: {One=1, Two=2}  
  
//map的键  
System.out.println("Keys: " + numbers.keySet()); // Keys: [One, Two]  
  
//map的值  
System.out.println("Values: " + numbers.values()); // Values: [1, 2]  
  
//map的条目  
System.out.println("Entries: " + numbers.entrySet()); // Entries: [One=1, Two=2]  
  
//从map集合中删除元素  
int value = numbers.remove("Two");  
System.out.println("被删除的值是: " + value); // 被删除的值是: 2  
}  
}

结束

这些可以助你快速入门使用java，后续更多方法、数据类型、代码逻辑、底层、框架、第三方库需要我们之后自行学习，后续我会推出更多的速通学习文章，例如SpringBoot等等，我喜欢讲速度的同时不影响质量，以求一个最佳效率。

有什么好的想法建议可以联系我