JavaSE基础
JavaSE 基础
注释
- 在代码量较多时，注释能让我们更好的理解程序
- 注释不会被执行。
- 书写注释是每个程序员必须练成的一种好习惯。
- Java中的注释有三种
- 单行注释
- 多行注释
- 文档注释(JavaDoc)
用法如下：
public class HelloWorld {
public static void main(String[] args) {
//单行注释语法：//注释内容
/*
多行注释语法：外部的语法包裹注释内容
*/
//JavaDoc：文档注释 语法：/**注释内容*/ (常用与变量解释)
/**
* @Author 王玉星
*/
}
}
关键字与标识符
关键字
Java中常用的关键字如下图所示：
标识符
用于区分Java中数据，如同（人的名字，计算机编号等）
- 所有的标识符都是字母(A-Z、a-z)，美元符($)，或者下划线(_)开头（首字母）。
- 首字母之后可以是任意字符组合。（除特殊符号如 @，#，%等）。
- 标识符是大小写敏感的。
- 可以使用中文或拼音来命名标识符，但是不建议使用。
数据类型
-
强类型语言
要求变量的使用要严格符合规定，所有变量都必须先定义后使用。（安全性高、速度慢。）
-
弱类型语言
要求变量的使用要符合规定。（安全性低、速度快。）
Java数据类型的分类
-
基本类型
-
引用类型
数据类型扩展及其面试题讲解
-
数据类型扩充
-
整数拓展
二进制(0b开头)、八进制(0开头)、十六进制(0x开头)。
如下：
010 = 8 （八进制）
0x10 = 16 （十六进制）
-
浮点数拓展
import javax.xml.bind.SchemaOutputResolver; public class Demo01 { public static void main(String[] args) { /* -------------------------------------------- 浮点数拓展 float 有限 离散 舍入误差 大约 接近但不等于 double 特别提醒：最好完全避免使用浮点数进行比较。（比较结果容易出错） 可以使用BigDecimal 数学工具类。之后会说。 */ float f = 0.1f; double d = 1.0/10; //比较结果 System.out.println(f == d); //false float f1 = 446746156441441f; float f2 = f1 + 1; System.out.println(f1 == f2); //true /* 字符拓展 所有的字符本质还是数字。 利用编码表进行互相转换：Unicode表 ，2字节，范围(0~65536) 转义字符 \t 制表符 \n 换行符等。 */ //内存机制： String sa = new String("a"); String sb = new String("a"); System.out.println(sa == sb); //false(不同的对象) String sc = "a"; String sd = "a"; System.out.println(sc == sd); //true(同样的内容只能有一份) //布尔值拓展 boolean flag =true; if (flag == true){} //新手 if(flag){} //老手 //两个表示内容相同 } }
-
类型转换
由于Java是强类型语言，所以要进行有些运算的时候，需要用到类型转换。
运算时，不同类型转换为同意类型才进行运算。
- 自动类型转换：根据下图的顺序，由左到右，会自动转换。（低——高 ）自动转换
- 强制类型转换：由高到低，需要强制转换。格式为： (转换类型)转换变量
注意点！！！
- 不能对布尔值进行转换。
- 不能把对象类型转换为不相干类型（中国转换为int型）。
- 高容量转低容量的时候，需要强制转换。
- 转换时可能出现内存溢出，或者精度丢失的问题。
变量
变量：就是可以改变的量。
Java是强类型语言，每个变量都必须声明其类型。
Java变量是程序中最基本的存储单元，其中包括变量名，变量类型，变量的作用域。
- 变量名：满足标识符即可。
- 变量类型：即为Java的数据类型，可以是基本类型，也可以是引用类型。
- 变量的作用域：变量可作用的范围。
变量的声明：
// type VarName [=value] [{,varName[=value]}];
// 类型 变量名 = 变量值; []代表可加，可不加,{}代表可以重复多次。
int a = 2;
String name = "张三";
String name1 = "张三", sex = "男", age = "20"; //不推荐使用
变量的作用域：
- 类变量：用 static 修饰，作用域为整个类。
- 实例变量：作用域为new 类名的大括号内。
- 局部变量：作用域为所使用方法的括号内。
public class Variable {
static int allClicks = 0; //类变量
String str = "hello world"; //实例变量
public void method(){
int i = 0; //局部变量
}
public void setme(){
Variable variable = new Variable();
System.out.println(variable.str);
}
}
常量：初始化后不可改变的值！
final 类型 常量名=值;
final double PI = 3.14
变量的命名规范：
- 类成员名：首字母小写后每个单词首字母大写 lastName
- 局部变量：首字母小写后每个单词首字母大写 fristNum
- 方法名：首字母小写后每个单词首字母大写 setName
- 常量： 大写字母和下划线 MAX_VALUE
- 类名： 首字母大写后每个单词首字母大写 PeopleNum
运算符
Java支持的运算符：
- 算术运算符：+，-，*，/，%（膜运算：取余），++，--
- 赋值运算符：=
- 关系运算符：> , < , >= , <= , ==（java里等于要用两个等于号） , != （不等于） instapceof
- 逻辑运算符：&&（与）,||（或）,!（非）
- 位运算符：&，|，^，~，>>，<<，>>>（了解）
- 条件运算符？：
- 扩展赋值运算符：+=，-=，*=，/=
public class Demo2 {
public static void main(String[] args) {
/*
A=0011 1100
B=0000 1101
--------------------------------------------------------
A&B = 0000 1100 如果A和B的数字对应位都为1则为1，如果不同则为0
A|B = 0011 1101 如果A和B的数字对应位都为0则为0，如果不同则为1
A^B = 0011 0001 如果A和B对应位相同则为0，如果不相同就是1
~B = 1111 0010 和原来的数字完全相反
面试题！！！！如何提高2*8的计算速度，使用位运算符
通过左移或右移 运算符，移动一位*2 或/2
2*8 = 16 2*2*2*2
<< *2
>> /2
0000 0000 0
0000 0001 1
0000 0010 2
0000 0011 3
0000 0100 4
0000 1000 8
0001 0000 16
*/
System.out.println(2<<3);//16
System.out.println(16>>3);//2
}
}
包机制
为了更好的组织类，Java提供了包机制，用于区别类名的命名空间
- 包命名的语法格式：
package pkg1[.pkg2{[.pkg3]}];
-
一般利用公司域名倒置作为包名
-
为了能使用某一个包的成员，我们需要在Java程序中明确导入该包，使用 import 语句可完成此功能。
import pkg1{[.pkg2]}.(类名|*);
Java Doc
javadoc命令是用来生成自己的API文档。
javadoc -encoding UTF-8 -charset UTF-8 文件路径加名字(hello.java)
在写文档注释时，有以下参数：
- @author 作者名
- @version 版本号
- @since 指明需要最早的jdk版本
- @param 参数名
- @return 返回值情况
- @throws 抛出异常情况
Java流程控制
用户交互Scanner
Scanner对象：是Java5的新特新，我们可以0通过 Scanner 类来获取用户输入。
语法格式：
Scanner sc = new Scanner(System.in)
常用 Scanner 的方法：
next()与nextLine：获取用户输入的字符串。
hasNext() 与 hasNextLine()判断是否还有输入的数据。
next 与 nextLine()
next()：不能得到带空格的 字符串。
nextLine()：可以得到回车之前的使用字符串，可以是空白。
Sanner用完后记得关闭 close()。
还有一种用法，判断输入的数据类型是什么类型。
next类型()
hasnext类型()
eg：
nextInt()
nextDouble()
hasnextDouble()
顺序结构
Java 的基本结构就是顺序结构，按照顺序一步一步执行。
选择结构
-
if 单选择结构
if (布尔表达式){ 执行语句; } -
if 双选择结构
if (布尔表达式){ 执行语句; }else{ 执行语句; } -
if 多选择结构
if (布尔表达式){ 执行语句; }else if(布尔表达式){ 执行语句; }else if(布尔表达式){ 执行语句; }else if(布尔表达式){ 执行语句; }else{ 执行语句; } -
嵌套 if 结构
if (布尔表达式){ if (布尔表达式){ 执行语句; }else{ 执行语句; } }else{ if (布尔表达式){ 执行语句; }else{ 执行语句; } } -
switch 结构
/* expression和value：支持的数据类型为：int char short byte java 7 之后支持:String。 */ switch (expression){ case value: 执行语句; break;//可选 case value: 执行语句; break;//可选 // case 可以无限多 default: //可选，只能有一个 执行语句; }
循环结构
-
while 循环
/* 1. 只要布尔表达式为真，循环会一直进行。 2. 大多数情况需要循环停下来。 */ while (布尔表达式){ 循环体; } -
do while 循环
/* 1. while 与 do while 的区别，while先判断后执行，do while先执行后判断。 2.do while循环能保证循环至少执行一次。 */ do{ 循环体; }while(布尔表达式); -
for 循环
/* 1. for 循环语句是支持迭代的一种通用结构，是最有效，最灵活的循环结构。 2. for 循环次数在执行前就会被确定。 */ for(初始化;布尔表达式;条件更新){ 循环体; } -
增强 for 循环
/* Java 5 引入，主要用于数组或集合，遍历时。 */ for(声明语句:表达式){ } -
break 与 continue
break：在任何循环语句中，使用break 结束循环体
continue：在一个循环中，遇见continue 结束循环体，进行下一次循环。
Java 的方法
什么是方法
Java方法：指语句的集合，它们组成成一个功能。
- 方法是解决一类问题的步骤的有序组合。
- 方法包含于类中或对象中。
- 方法在程序中被创建，在其他地方被引用。
方法的定义
/*
修饰符：修饰该方法的调用方法和访问权限。
返回值类型：根据方法的要求，获取相对的返回值。
方法名：方法的实际名字，方法在其他地方调用的依据。
参数类型：参数相当于占位符，在其他方法调用时传如参数，完成方法的功能。
方法体：解决一个功能所需要的代码块。
*/
修饰符 返回值类型 方法名([参数类型 参数名{, 参数类型 参数名}]){
方法体;
return 返回值; //可选
}
面试题：
Java都是值传递还是引用传递。
Java都是值传递。
方法的重载
定义：在一个类中，相同函数名，但形参不同的函数。
方法重载的规则
- 方法名必须相同
- 参数列表不同（个数不同，类型不同，参数顺序不同都可以）。
- 方法的返回值可以相同，也可以不同。
- 仅仅返回类型不同不足以成为方法的重载。
可变参数
/*
在方法声明中，在指定参数类型后加一个(...)
一个方法体中只能有一个可变参数，它必须是方法的最后一个参数。
*/
public static void test(int... i){
for(int x:i){
System.out.println(x);
}
}
递归(面试高频点)
递归就是：自己调用自己，适用于调用层级小的，调用层级大容易照成栈溢出，不推荐。
数组
数组概述
- 数组是有相同类型数据的有序集合。
- 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。
- 其中，每一个数据称为一个数组元素，每个元素通过一个下标访问它们。
数组声明与创建
dataType[] arrayRefVar; // 首选方法
dataType arrayReVar; //效果相同
// Java语言使用 new 操作符来创建数组，语法如下
dataType[] arrayRefVar = new dataType[arraySize];
int [] a = new int[5];
//数组元素通过下标访问，下标从 0 开始。
// 获取数组长度 数组名.length
数组的初始化
// 静态初始化
int[] a = {1,2,3};
// 动态初始化
int[] a = new int[2];
a[0]=1;
a[1]=2;
数组的特点
- 数组长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
- 其元素类型必须相同，不允许出现混合类型。
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
- 数组变量的引用类型，数组也可以看成是对象，数组中的每个元素相当于对象的成员变量。数组本身就是对象，Java中对象是堆存储，因此数组无论保存什么类型，都是存储在堆中。
- 数组可以当作方法的参数。
- 数组也可以做返回值。
public class Demo2 {
public static void main(String[] args) {
int[] a = {1,2,3,4,5};
Demo2 demo2 = new Demo2();
demo2.printArray(a);
demo2.reverse(a);
}
public void printArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]+" ");
}
}
//数组的反转
public int[] reverse(int[] arrays){
int[] result = new int[arrays.length];
for (int i=0,j=result.length-1;i < arrays.length;i++,j--) {
result[j] = arrays[i];
}
return result;
}
}
多维数组
-
二维数组(多维数组演生就可以了)
int[][] a= new [2][5] //定义 int[][] a= {{1,2},{3,4},{5,6}}
Arrays类
import java.util.Arrays;
/*
* 数组的工具类 java.util.Arrays
* API文档提供了一个工具类，供我们使用。
* 详情查看API文档，
* Arrays类中的方法都是static修饰，调用时，可以不用new对象。
* 常用的功能：
* 1. 给数组赋值，即填充数组。fill方法
* 2. 对数组进行排序，升序。sort方法
* 3. 对两个数组的值进行比较，看数组是否相同。equals方法
* 4. 查找数组元素，binarySearch方法，利用已经排序好的数组进行二分法查找元素。
* */
public class Demo2 {
public static void main(String[] args) {
int[] a = {23,41,5,3,746,998};
//打印数组元素
System.out.println(Arrays.toString(a));
//排序数组
Arrays.sort(a);
System.out.println(Arrays.toString(a));
//数组填充
Arrays.fill(a,0);
System.out.println(Arrays.toString(a));
//其余方法及其填充的其他用法查看jdk 开发文档。
}
}
排序算法
-
冒泡排序（最出名的排序算法之一）总共八大排序算法。
import java.util.Arrays; public class Demo03 { /* * 冒泡排序： * 比较数组中前一个数组中前一个数组与后一个数的大小，在更具我们需要升序还是降序，进行值的互换。 * 每次比较会产生最大，或最小的数。 * 下一轮排序可以减少一次排序 * 以此循环，直到结果出来。 * 时间复杂度O(n^2) * */ public static void main(String[] args) { int[] a = {12, 32, 443, 6, 4, 46, 3413, 232}; int[] bubbleSort = bubbleSort(a); System.out.println(Arrays.toString(bubbleSort)); } //冒泡排序 public static int[] bubbleSort(int[] array) { int temp = 0; for (int i = 0; i < array.length - 1; i++) { for (int j = 0; j < array.length - 1 - i; j++) { if (array[j + 1] > array[j]) { //更改大于小于，可以使我们的到的顺序是升序或者降序。 temp = array[j]; array[j] = array[j + 1]; array[j + 1] = temp; } } } return array; } }
数组进阶：稀疏数组
public class Demo04 {
public static void main(String[] args) {
//创建一个二维数组 11*11
//0表示没有棋子，1表示黑棋，2表示蓝棋
int[][] chessArr = new int[11][11];
chessArr[1][2] = 1;
chessArr[2][3] = 2;
//输出原始的二维数组
System.out.println("原始的二维数组：");
for (int[] value : chessArr) {
for (int j = 0; j < value.length; j++) {
System.out.print(value[j] + "\t");
}
System.out.println();
}
//将二维数组转换为稀疏数组
//1.先遍历二维数组得到非零数据的个数
int sum = 0;
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if (chessArr[i][j] != 0){
sum++;
}
}
}
//2.创建对应的系数数组
int[][] sparseArr = new int[sum+1][3];
//给系数数组赋值
sparseArr[0][0] = 11;
sparseArr[0][1] = 11;
sparseArr[0][2] = sum;
//遍历二维数组将非零的值存放到稀疏数组
int count = 0;
for (int i = 0; i < chessArr.length; i++) {
for (int j = 0; j < chessArr[i].length; j++) {
if (chessArr[i][j] != 0){
count++;
sparseArr[count][0] = i;
sparseArr[count][1] = j;
sparseArr[count][2] = chessArr[i][j];
}
}
}
//输出稀疏数组
System.out.println();
System.out.println("稀疏数组：");
for (int[] ints : sparseArr) {
System.out.println(ints[0] + "\t" + ints[1] + "\t" + ints[2]);
}
//将稀疏数组恢复成二维数组
//1.先读取稀疏数组的第一行，根据第一行创建二维数组
int[][] chessArr2 = new int[sparseArr[0][0]][sparseArr[0][1]];
//2.读取稀疏数组后几行赋值给二维数组
//注意这里是从第二行开始
for (int i = 1; i < sparseArr.length; i++) {
chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
}
System.out.println();
System.out.println("恢复后的二维数组：");
for (int[] row : chessArr2) {
for (int data : row) {
System.out.print(data+"\t");
}
System.out.println();
}
}
}
面向对象编程
什么是面向对象
Java核心思想就是面向对象编程（OOP）
面向过程思想
- 步骤清晰简单。
- 面向过程适合处理一些简单的问题
面向对象思想
- 物理类聚，分类的思维模式。将问题分类，在进行问题处理。
- 面向对象适合处理复杂的问题，适合处理需要多人协作的问题。
什么是面向对象
面向对象编程（Object Oriented Programming，OOP）
面向对象编程的本质：一类的方式组织代码，以对象的组织（封装）数据。
抽象：将有相同特性的一部分属性包装起来。
三大特性：
- 封装性：将一系列的属性和方法封装在类中。
- 继承性：将一个类的方法原原本本的给另一个类。
- 多态性：同一个事物，执行相同操作，所得到不同结果。
类与对象的关系
类：是对某一具体事务的抽象。将事务抽象成为一定的数据类型。对某一事物的描述，单不能代表具体的事物。
如：人类，动物类，等。
对象：是对类的具体实例
如：小明（人类实例化出来的）。
创建与初始化对象
使用 new 关键字来创建对象。
使用 new 创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认初始化，以及对类中构造器的调用。
类中的 构造器也称构造方法 是在进行创建对象的时候必须要调用的。
public class Student { String name; int age; public void show(){ System.out.println(this.name+"今年"+age+"岁"); } }public class Demo05 { public static void main(String[] args) { Student student = new Student(); student.show(); Student student2 = new Student(); student2.name = "小明"; student2.age = 2; student2.show(); } }
构造方法
构造方法的特点：
- 必须和类名相同。
- 必须没有返回值类型。
