Java基础知识
一、基础知识，通过代码进行解释
package helloJava;//package 包的关键字，相当于整个代码的目录
public class helloMain {
static String strr = "nihao";//全局变量//必须得用static定义，否则程序会出错
private static String str = "是我学习Java语言的最佳书籍";
public static void main(String[] args) {//必须有该句，才能运行程序，且格式是固定的
int s = 0;
String str = "";//局部变量
System.out.print("《Java入门到精通》！" + "\r\n" + str + strr);
}
}java中main()方法为主方法，是程序开始执行的地方，必须按照如下的方式进行定义
public static void main(String[] args)
//单行注释
/**/ 多行注释，但在多行注释中，不能嵌套多行注释
/** */ 为文档注释
二、数据基本类型
三、变量与常量
1. 常量：final
final 数据类型 常量名称 = 值
final double PI = 3.1415926
2. 成员变量
成员变量又分为 实例变量和静态变量
例子中 String str = "";//局部变量 为实例变量，
static String strr = "nihao"; 为 静态变量， 变量前加 static 即为 静态变量，可跨类
还可以使用 类名.静态变量 来调用
四、运算符
1. 等号=
int a,b, c;
c = 0;// 从 最右边的 = 的右边 开始处理
a = b = c = 4;// c4赋值给c， c赋值给b， b赋值给a//但不建议这样用
2.自增自减
自增自减，必须是整型或者 浮点型(c++没这个)，加减1的意思
int a = 4;
int b = a++;// 运算结果，a=4 b=5
3.逻辑运算符： 表达式结果为 boolean类型，真或假
&& 、 & 都表示 逻辑与
例子： boolean p1 = false; boolean p2 = true;
p1& p2必须把p1 p2两边表达式都算完后，才能算出整个表达式的结果；没有短路的功能
p1&& p2有短路的功能, 此处 p1为false，则后面就不用看p2了，表达式结果为false
4.位运算符
& 按位与
| 按位或
~ 按位取反
^ 按位异或
<< 左移( --->>箭头)
>>右移
>>> 无符号右移 无论最高位是0还是1，左侧被移空的高位填 0
注意：移位运算只限于 整型类型
了
5.三元运算
boolean a = 20 > 0 ? true : false;
6.运算符的优先级
自增自减 > 算术运算 > 比较运算 > 逻辑运算 > 赋值运算
7.类型转换
强制类型转换
五、流程控制
if for while 等就不在记录了。本文中只简单记录一下重点知识。
switch中 case中常量名称必须不相同。
foreach的增强语法：就是 for( : );;;实际上 是没有foreach这个关键词的，我在初学时一直用foreach，然后编译器却说foreach未定义，就是因为没有这个关键词，还是用for弄出来的
int arr2[] = {1,2,3,4,5};//初始化
for(int i : arr2)
{
System.out.print("元素：" + i+ "\r\n");
}
六、字符串
String s;//声明的字符串必须初始化之后才能用，否则编译器会报错
1.创建字符串
(1) String(char [])
char a[] = {'g','o','o','d'};
String newSt = new String(a);
//上面等价于
//String newSt = new String("good"); 跟上句一个意思
String newSt2 = new String(a, 1,2);//输出 oo(2)String(char[], 开始位置, 截取长度)
char a[] = {'g','o','o','d'};
String newSt = new String(a);
//上面等价于
//String newSt = new String("good"); 跟上句一个意思
String newSt2 = new String(a, 1,2);//输出 oo(3)直接字符串赋值
String str = "是我学习Java语言的最佳书籍";2.连接字符串
使用 + 即可
3.字符串常用属性
String str = "是我学习Java语言的最佳书籍";(1)长度 str.length()
(2)查找
str.indexOf() 返回的是首次出现的位置
str.LastIndexOf 返回的是最后一次出现的位置
(3)获取指定位置的字符
char ch = str.charAt(int nindex)
(4)截取字符串 substring
String str = "";
char a[] = {'g','o','o','d'};
String newSt = new String(a);
//上面等价于
//String newSt = new String("good"); 跟上句一个意思
String newSt2 = new String(a, 1,2);//输出 oo
String str1 = newSt.substring(1);// str1=ood 从第1个开始，直到字符串结束
String str2 = newSt.substring(1,3);// str1=ood 从位置1个开始，到位置3个结束
String str3 = newSt.trim();//去除字符串前后的空格
(5)字符串 替换replace
(6)判断字符串的开始与结尾
boolean b1 = newSt.startsWith("go");//以XX为开头
boolean b2 = newSt.endsWith("od");//XX为结尾(7)判断字符串是否相等
不能以==进行简单的判断，即使字符串内容相同，但其内存地址也不同。
equals()//比较字符串，区分大小写----》返回值为 boolean
equalsIgnoreCase()//比较字符串，不区分大小写---》返回值为 boolean
int b5 = str1.compareToIgnoreCase(str2);//比较字符串，不区分大小写 ---》返回值为 int
int b6 = str1.compareTo(str2);//比较字符串，区分大小写 ---》返回值为 int
boolean b3 = str1.equals(str2);//比较字符串，区分大小写
boolean b4 = str1.equalsIgnoreCase(str2);//比较字符串，不区分大小写
//按照字典顺序进行比较，只有当字符串一样时，才返回0， 其他有正值，有负值
int b5 = str1.compareToIgnoreCase(str2);//比较字符串，不区分大小写
int b6 = str1.compareTo(str2);//比较字符串，区分大小写(8)字符串分割 split
String strCondext = "alsdj-shfh,sdhg=skdh";
strCondext.split("-|=|,");//分割符号为- = , 三个分隔符进行分割//多个分隔符用 |
String strCondextIP = "192.168.100.144";
String[] fisrtSplit = strCondextIP.split("\\.");//使用.进行分割//数组 [192] [168][100][144]
String[] secondSplit = strCondextIP.split("\\.", 2);//使用.进行分割//数组 [192] [168.100.144]
(9)字符串格式化Format
(10)正则表达式
(11)字符串生成器StringBuilder---创建不定长的字符串
程序中如果不断的添加字符串，则建议使用StringBuilder
七、数组
1.定义
下标从0开始的
int arr[] = new int[5];//分配内存//数组中元素初始值为0
int arr1[] = new int[]{1,2,3,4,5};//初始化
int arr2[] = {1,2,3,4,5};//初始化
int av[] = new int[]{1,2,3,4,5};
for(int i : arr2)
{
System.out.print("元素：" + i+ "\r\n");
}
int arr22[][] = {{1,2,3},{4,5,6}};//二维数组的初始化2.操作
java.util包含了Array类的所有操作
(1)数组填充fill
fill(数组, 值);//对数组a 整个赋值为5
int arr2[] = {1,2,3,4,5};//初始化
Arrays.fill(arr2, 99);
for(int i : arr2)
{
System.out.print("元素：" + i+ "\r\n");
}(2)数组排序sort
Array类的其他方法请参考书籍《Java从入门到精通》
(3)数组查询
binarySearch(Object[], Object key)
binarySearch(Object[],int fromindex,int tolndex,Object key)
使用数组查询之前必须先对数组排序sort, 返回结果为排序后的数组元素所在的位置
八、类和对象
类：封装、继承、多态，与c++类似，不在赘述
Java类的默认访问权限是包级私有（package-private）。Java类的默认访问权限是包级私有，它限制了类的访问范围仅限于同一个包中的其他类。这种访问权限的设定有助于实现封装和模块化，提高代码的可维护性和安全性。
this关键字： this引用的就是本类的一个对象 this.name = name;
类的构造方法(c++叫构造函数)：与类名相同，没有返回值，函数自动调用；若没有定义构造方法，程序会自动创建一个不带参数的构造方法。
1.静态成员
2.不能将方法中的局部变量声明为static类型
3.类的主方法
主方法是类的入口点，定义了程序从何处开始，控制整个程序的流程。
4.对象
(1)对象的创建：
(2)访问对象的属性和方法
对象.类成员
(3)对象的引用
(4)对象的销毁
自动回收机制，不需要手动释放，但只能回收由 new 创建的对象。
finalize()来实现非new创建的对象。
5.类中默认权限为 包级私有
九、包装类
十、数字处理类
导入库： import java.text.DecimalFormat;
DecimalFormat类，是NumberFormat的一个子类，用于格式化十进制数字。
1.随机数：
Math.Random
还有java.util.Random类
Random r=new Random();
2.大数字运算
在Java 中提供了大数字的操作类，即java.math.BigInteger 类与java.math.BigDecimal类。这两个类用于高精度计算，其中 BigInteger 类是针对大整数的处理类，而 BigDecimal类则是针对大小数的处理类.
下面为核心技术
十一、接口、继承、多态
//父类
class Testsc{
public Testsc()
{
System.out.print("父类构造" );
}
protected void DoSomthing()
{
;
}
protected Testsc DoIdlt()
{
return new Testsc();
}
}
//子类
class Testsc_sub extends Testsc{ //extends关键字为继承
public Testsc_sub()
{
super();//调用父类构造方法
super.DoSomthing();//调用父类的成员函数
System.out.print("子类构造" );
}
protected void DoSomthing()//重写父类方法
{
;
}
public void DoSomthingNew()//新增函数
{
;
}
public Testsc_sub DoIdlt()//重写父类方法//子类重写时，权限只能升级，不能降级，不能由protected变为private
{
return new Testsc_sub();
}
}调用构造方法的顺序，首先是顶级父类，然后是上一级父类最后是子类。也就是说，实例化子类对象时首先要实例化父类对象，然后再实例化子类对象，所以在子类构造方法访问父类的构造方法之前，父类已经完成实例化操作。
instanceof 向下转型时需要使用
不定长参数
private int Add(int···a)；//int···a 实际上是一个数组
抽象与接口
abstract定义抽象类的关键字，只要类中有一个抽象方法，此类就被标记为抽象类。抽象类被继承后，要重写所有的抽象方法。类不能同时继承多个父类，只能有一个父类，由此出现了接口。
使用interface定义接口类，必须为public，没有定义时默认为public，接口类中没有方法体，接口类中可以实现多重继承。
十二、java的高级特性
用package创建包，包的名称要使用小写字母。
1. import导入包
(1)import导入包
import com.lzw.Math//指定com.lzw包中的Math类在程序中可以使用如果想使用包中更多的类，可以 加 *
import com.lzw.*//(2).import导入静态成员变量
import static java.lang.System.out;具体代码如下：
package helloJava;
import java.util.*;
import static java.lang.System.out;
public class helloMain {
public static void main(String[] args) {
System.out.print("《Java入门到精通》！" + "\r\n" );
out.print("nihao!你好");
//System.out.print(secondSplit);
}
}
2.final 常量
final double PI = 3.1415926;
private final int value_1 = 15;//声明一个final常量
private static final int value_2 = 1455;//声明一个final、 static 常量
private final Testsc_sub test = new Testsc_sub();//声明一个final引用
private Testsc_sub test2 = new Testsc_sub();//声明一个不是final引用
private final int a = {1,2,3,4,5,6};//声明一个定义为final的数组注意下面a1与a2的值
package helloJava;
import static java.lang.System.out;
import java.util.*;
public class helloMain {
String str = "";
int au = 0;
private final int value_1 = 15;//声明一个final常量
private static final int value_2 = 1455;//声明一个final、 static 常量
private final Testsc_sub test = new Testsc_sub();//声明一个final引用
private Testsc_sub test2 = new Testsc_sub();//声明一个不是final引用
private final int avu[] = {1,2,3,4,5,6};//声明一个定义为final的数组
//必须加static 否则会报错
public static class FinalStaticData{
private static Random randm = new Random();//实例化一个randm对象
//随机产生一个0-10的值给final a1
private final int a1 = randm.nextInt(10);非static
//随机产生一个0-10的值给static final a2
private static final int a2 = randm.nextInt(10);static
}
public static void main(String[] args) {
java.lang.System.out.print("nihao!你好");
FinalStaticData fData = new FinalStaticData();//实例化一个对象
out.print("1重新实例化对象调用a1的值: " + fData.a1 + "\r\n");
out.print("1重新实例化对象调用a2的值: " + fData.a2 + "\r\n");
//实例化另外一个对象
FinalStaticData fData2 = new FinalStaticData();//实例化一个对象
out.print("2重新实例化对象调用a1的值: " + fData2.a1 + "\r\n");
out.print("2重新实例化对象调用a2的值: " + fData2.a2 + "\r\n");
}
}
输出：注意看无论实例化哪个对象，其a2的值都是一样的
nihao!你好1重新实例化对象调用a1的值: 5
1重新实例化对象调用a2的值: 1
2重新实例化对象调用a1的值: 6
2重新实例化对象调用a2的值: 13.定义为final的方法不能被重写P206
防止子类重写该方法，且执行效率比非final效率高。
如果父类某些方法设置为private，则子类无法访问该方法，所以一个被定义为private的方法被指定为final类型。所以，不需要对private的方法设置为final类型。
4.定义为final的类不能被继承
如果类定义为final类，则类中方法和成员变量隐式的变成了final类型。
图片来自于书籍：《来自于： 《Java从入门到精通》》