目录
一、Java基础
1、注释
2、标识符和关键字
（1）关键字
（2）标识符
3、数据类型
（1）数据类型知识点
（2）位、字节、字、字符
（3）数据类型转换
4、变量、常量、作用域
（1）变量
（2）变量作用域
（3）变量的命名规范
（4）常量 final
5、运算符
6、JavaDoc
二、Java流程控制
1、用户交互Scanner
2、顺序结构、选择结构、循环结构
选择结构
循环结构
3、for循环应用
4、break 和 continue
三、方法
1、方法
2、方法重载
3、可变参数
四、数组
1、数组概述
2、数组声明创建
3、数组初始化
4、数组的四个基本特点
5、数组边界
6、数组使用
7、多维数组
8、Arrays类
9、冒泡排序
10、稀疏数组
五、面向对象
1、面向对象
2、方法
（1） 方法的定义
（2）静态方法和非静态方法
（3）形参和实参
（4）值传递和引用传递
3、对象的创建分析
（1）使用new关键词创建对象
4、抽象类及接口
（1）抽象类abstract
（2）接口interface
5、内部类
六、面向对象三大特性
1、封装
2、继承 extends
（1）继承概述：
（2）super关键字：
（3）this关键字：
（4）重写与重载
（5）类型转换与多态
3、多态
（1）代码演示
（2）注意：
（3）不能被重写：
（4）instanceof 引用类型转换
（5）匿名代码块、静态代码块、构造方法的执行顺序
七、异常处理
根据B站狂神Java基础视频，整理的知识点。
指路视频
一、Java基础 1、注释- 单行注释 //...
- 多行注释
- 文档注释
- 所有关键字都是小写
- String不是关键词，是一个类
- Java标识符是以字母、下划线（_）、美元符号（$）等开始的一个字符序列
- 后面可以跟字母，下划线，美元符号，数字等字符
- 位（bit）：是计算机 内部数据 存储的最小单元。
- 字节（byte）：是计算机 数据处理 的基本单位。一般用B表示
- 1B（byte，字节）=8bit（位）
- 字符：是指计算机中使用的字母、数字、字和符号
- 自动类型转换 ：低到高
低——————————————————————>高
byte，short，char—> int—> long—> float—> double
- 强制类型转换 ：（类型）变量名 由高到低
- 转换的时候可能会出现内存溢出或者是精度问题
- Java变量是程序中最基本的存储单元，其要素包括变量名、变量类型和作用域
- 每一个变量都有数据类型
- 变量名必须是合法的标识符
- 变量声明必须以分号结尾
- 类变量：static
- 局部变量：必须声明和初始化值。
- 实例变量：从属于对象，如果不初始化值，返回这个类型的默认值。
- 基本数据类型返回0，引用类型返回null，布尔值默认是false
- 所有变量、方法、类名：见名知意
- 类成员变量：首字母小写和驼峰原则： monthSalary .除了第一个单词以外，后面的单词首字母大写 lastName
- 局部变量：首字母小写和驼峰原则
- 常量：大写字母和下划线： MAX_VALUE
- 类名：首字母大写和驼峰原则： Man , GoodMan
- 方法名：首字母小写和驼峰原则：run(),runRun()
- 一般用大写字母表示
（1）算术运算符 + - * / % ++ --
（2）赋值运算符 =
（3）关系运算符 > < >= <= == != instanceof
（4）逻辑运算符 && || ! （注意短路运算）
（5）位运算符 &与 |或 ^异或 ~取反 >>右移除2 <<左移乘2 >>> （二进制）
（6）条件运算符 ？ ：
（7）扩展赋值运算符 += -= *= /=
- 二元运算符
- 字符串连接符 “+” String.
int a=10;
int b=20;
System.out.println(""+a+b); //1020 输出字符串连接后的结果
System.out.println(a+b+""); //30 输出a+b后的字符串
-
三元运算符 x?y:z （如果x==true，则输出y，否则输出z）
- Javadoc命令是用来生成自己API文档的
- 参数信息
- @author 作者名
- @version 版本号
- @since 指明需要最早使用的jdk版本
- @param 参数名
- @return 返回值情况
- @throws 异常抛出情况
（1）java.util.Scanner 可以通过Scanner类来获取用户的输入
（2）基本语法：Scanner s = new Scanner(System.in);
（3）Scanner对象：
- next():
- 一定要读取到有效字符后才可以结束输入
- 对输入有效字符之前遇到的空白，next()方法会自动将其去掉
- 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符
- next()不能得到带有空格的字符串
//创建一个扫描器对象，用于接受键盘数据
Scanner scanner= new Scanner(System.in);
System.out.println("使用next方式接收：");
//判断用户有没有输入字符串
if(scanner.hasNext()){
//使用next方式接收
String str=scanner.next();//程序会等待用户输入完毕
System.out.println("输出的内容为："+str);
}
//凡是属于IO流的类如果不关闭会一直占用资源,所以在最后用完之后要关闭
scanner.close();
- nextLine():
- 以Enter为结束符，也就是说nextLine()方法返回的是输入回车之前的所有字符
- 可以获得空白
//创建一个扫描器对象，用于接受键盘数据
Scanner scanner= new Scanner(System.in);
System.out.println("使用nextLine方式接收：");
//判断用户有没有输入字符串
if(scanner.hasNextLine()){
//使用nextLine方式接收
String str=scanner.nextLine();//程序会等待用户输入完毕
System.out.println("输出的内容为："+str);
}
//凡是属于IO流的类如果不关闭会一直占用资源,所以在最后用完之后要关闭
scanner.close();
2、顺序结构、选择结构、循环结构
选择结构
（1）if
（2）switch
循环结构（1）while
（2）do...while
（3）for
3、for循环应用//利用for循环打印九九乘法表
- 先打印第一列，1*i
- 把固定的1再用一个循环包起来
- 去掉重复项：i<=j
- 调整样式：print(打印)、println(打印后换行); t tab制表符
public static void main(String[] args) {
for(int j=1;j<=9;j++){
for(int i=1;i<=j;i++){
System.out.print(j+"*"+i+"="+(j*i)+"t");
}
System.out.println();
}
}
输出结果：
1*1=1
2*1=2 2*2=4
3*1=3 3*2=6 3*3=9
4*1=4 4*2=8 4*3=12 4*4=16
5*1=5 5*2=10 5*3=15 5*4=20 5*5=25
6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36
7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49
8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64
9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81
//打印一个三角形
public static void main(String[] args) {
//打印一个5行的三角形
for (int i = 1; i <=5; i++) {
for (int j = 5; j >=i; j--) {
System.out.print(" ");
}
for(int j=1;j<=i;j++){
System.out.print("*");
}
for(int j=1;j
输出结果：
*
***
*****
*******
*********
4、break 和 continue
- break用于强行退出循环，不执行循环中剩余的语句
- continue用在循环语句中，用于终止某次循环过程。接着进行下次是否循环的判定
// break和return的区别 break跳出switch，跳出循环；return 结束方法，返回一个结果
三、方法
1、方法
（1）定义：
修饰符 返回值类型 方法名（参数类型 参数名）{
...
方法体
...
return 返回值；}
（2）方法调用：对象名.方法名（实参列表）
2、方法重载
（1）重载：在一个类中，方法名字相同，而参数列表不同，即参数类型和参数数量不同。返回值类型可以相同也可以不同
（2）方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。
3、可变参数
（1）在方法声明中，在指定参数类型后加一个省略号（...）
（2）一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。
public static void main(String[] args) {
//调用可变参数的方法
printMax(34,4,3,2,56.2);
printMax(new double[]{1,2,3});
}
public static void printMax(double...i){
if(i.length==0){
System.out.println("No argument passed");
return;
}
double result=i[0];
//排序
for(int j=1;jresult){result=i[j];}
}
System.out.println("The max value is"+result);
}
输出结果 ：
The max value is56.2
The max value is3.0
（4）递归
//阶乘！
public static void main(String[] args) {
System.out.println(f(5));
}
public static int f(int n){
if(n==1){return 1;}
else{return n*f(n-1);}
输出结果：120
四、数组
1、数组概述
- 数组是相同类型数据的有序集合
- 数组下标是从0开始的
2、数组声明创建
（1）声明数组变量的语法：
dataType[ ] arrayRefVal; //首选的方法
dataType arrayRefVal[ ]; //效果相同
（2）Java语言使用new *** 作符创建数组：
dataType[ ] arrayRefVal=new dataType[arraySize];
（3）获取数组长度：array.length
3、数组初始化
（1）静态初始化 int[ ] a={1,2,3};
Man[ ] mans={new Man(1,1),new(2,2)};
（2）动态初始化 int[ ] a=new int[2];
a[0]=1;
a[1]=2;
（3）默认初始值
- 基本数据类型初始值为0
- char字符型初始默认值是null
- boolean布尔型的初始值是false
4、数组的四个基本特点
（1）其长度是确定的，数组一旦被创建，它的大小就是不可以改变的
（2）其元素必须是相同类型，不允许出现混合类型
（3）数组中的元素可以是任何数据类型，包括基本类型和引用类型
（4）数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。
数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。
5、数组边界
（1）下标的合法区间：[0,length-1]，如果越界就会报错；
（2）ArrayIndexOutOfBoundsException:数组下标越界异常！
6、数组使用
基本 *** 作
public static void main(String[] args) {
int[] arrays = {1, 2, 3, 4, 5};
for (int i=0;i< arrays.length;i++){
System.out.println(arrays[i]);
}
System.out.println("=========");
//计算所有元素的和
int sum=0;
for (int i=0;imax){max=arrays[i];}
}
System.out.println("max="+max);
System.out.println("=========");
}
输出结果：
1
2
3
4
5
=========
sum=15
=========
max=5
=========
反转数组
//反转数组
public static int[] reverse(int[] arrays){
int[] result=new int[arrays.length];
for (int i = 0,j=result.length-1; i
打印数组元素
//打印数组元素
public static void printArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.println(arrays[i]+" ");
}
}
7、多维数组
（1）
public static void main(String[] args) {
//[4][2]
int[][] array={{1,2},{2,3},{3,4},{4,5}};
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.println(array[i][j]);
}
}
}
//打印数组元素
public static void printArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.println(arrays[i]+" ");
}
}
输出结果：
1
2
2
3
3
4
4
5
8、Arrays类
9、冒泡排序
（1）算法思想：两两比较，逆序交换，最终结果为递增序列。代码为两层循环，外层冒泡轮数，里层依次比较。
public static void main(String[] args) {
int[] a={1,4,2,6,7,3,5};
//调用排序方法，返回一个排序后的数组
int[] sort=sort(a);
//打印数组
System.out.println(Arrays.toString(sort));
}
public static int[] sort(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]
输出结果： [1, 2, 3, 4, 5, 6, 7]
（2）优化排序
10、稀疏数组
五、面向对象
1、面向对象
（1）面向对象编程本质就是：以类的方式组织代码，以对象的组织（封装）数据
2、方法
（1） 方法的定义
修饰符 返回值类型 方法名(...) {
... //方法体
return 返回值；
}
扩展补充：
break和return的区别 ：break跳出switch，跳出循环；return 结束方法，返回一个结果
continue用在循环语句中，用于终止某次循环过程。接着进行下次是否循环的判定
（2）静态方法和非静态方法
- 定义静态变量和静态方法：在变量或方法名前加一个关键字static即可
- 实例成员为特定实例所有，只能通过对象名访问。
- 类成员（也称静态成员）为类所有，不属于某一个对象，可通过类名或对象名访问。
- 静态成员变量在生成该类的第一个对象时分配内存空间，该空间被类的所有实例共享。
- 非静态方法可以调用静态也可以是非静态的，但是非静态方法只能调用非静态方法
实例化这个类new 对象类型 对象名=对象值
（3）形参和实参
- 实际参数和形式参数的类型要对应
（4）值传递和引用传递
- 值传递：
- 引用传递：
3、对象的创建分析
（1）使用new关键词创建对象
- 构造器特点：①方法名与类名相同 ②并且没有返回值
- 作用：①使用new关键字,必须要有构造器 ②构造器一般用来初始化值
4、抽象类及接口
（1）抽象类abstract
（2）接口interface
5、内部类
六、面向对象三大特性
1、封装
（1）作用：
- 提高程序的安全性，保护数据
- 隐藏代码的实现细节
- 统一接口 系统的可维护性提高
（2（））属性私有 get/set
2、继承 extends
（1）继承概述：
子类继承父类。所有类的父类是Object类
Java中只有单继承，即一个子类只能有一个父类
（2）super关键字：
引用当前对象的父类。可以使用它访问父类中被覆盖的成员
调用父类的无参构造器，super()空语句必须在子类构造器的第一行； 也可以隐藏不写，默认就有这条语句。
- super调用父类的构造方法，必须在构造方法的第一个，否则会报错
- super必须只能出现在子类的方法或者构造方法中
- super和this不能同时调用构造方法
（3）this关键字：
表示对当前对象的引用。
当局部变量和类的成员变量同名时，在局部变量作用区域内成员变量会被隐藏，这时可以使用this来指明类的成员变量
（4）重写与重载
（5）类型转换与多态
//父类
public class B{
public static void test(){
System.out.println("B");
}
}
//继承
public class A extends B{
public static void test(){
System.out.println("A");
}
}
public class practice{
public static void main(String[] args){
//方法的调用只和左边定义的数据类型有关
A a=new A();
a.test(); //输出结果：A
//父类的引用指向了子类
B b=new A();
b.test();//输出结果：B
}
}
下面将父类和子类中的static去掉，输出结果发生了变化。
//父类
public class B{
public void test(){
System.out.println("B");
}
}
//继承
public class A extends B{
//Override 重写
public void test(){
System.out.println("A");
}
}
public class practice{
public static void main(String[] args){
//方法的调用
A a=new A();
a.test(); //输出结果：A
//重写只和非静态方法有关
B b=new A();//子类重写了父类的方法
b.test();//输出结果：A
}
}
非静态方法：重写
重写：
- 要有继承关系，子类重写父类的方法
- 方法名必须相同，参数列表必须相同。方法体不同
- 修饰符：范围可以扩大，但是不能缩小。 public>protected>default>private
- 抛出的异常：范围可以缩小，但不能扩大。
3、多态
（1）代码演示
public class A{
public void run(){
System.out.println("run");
}
}
public class B extends A{
public void run(){
System.out.println("son");
}
public void eat(){
System.out.println("eat");
}
}
public class test{
public static void main(String[] args){
//子类能调用的方法，都是自己的或者继承父类的
B a=new B();
//父类可以指向子类，但是不能调用子类独有的方法
A b=new B();
Object c=new B();
//子类重写了父类的方法，执行子类的方法
a.run();//输出结果:son
b.run();//输出结果:son
//对象能执行的方法，看对象左边的类型
a.eat();
( (A)b ).eat();//高转低强制转换
}
}
（2）注意：
- 多态是方法的多态，属性没有多态
- 多态存在条件：继承关系，方法需要重写，父类引用指向子类对象
（3）不能被重写：
- static 静态方法，属于类，它不属于实例
- final 常量，声明的方法不能再被重写
- private 私有方法
（4）instanceof 引用类型转换
System.out.println(X instanceof Y);
//能不能编译通过，就看X和Y之间是否存在父子关系。返回值为true或false
false与报错的区别：
- A(对象) instcnaceof B(类)结果为boolean型
- A和B比较之前会先判断A能不能转换成B类型，能则通过，不能则编译报错
（5）匿名代码块、静态代码块、构造方法的执行顺序
public class code {
//匿名代码块一般用来赋初始值
{
System.out.println("匿名代码块");
}
//静态方法只执行一次，并且首先执行静态方法
static{
System.out.println("静态代码块");
}
public code(){
System.out.println("构造方法");
}//构造方法名与类名相同
public static void main(String[] args) {
code person1 = new code();
System.out.println("=========");
code person2 = new code();
}
}
输出结果：
静态代码块
匿名代码块
构造方法 //注意：执行顺序
=========
匿名代码块
构造方法 //注意：静态代码块只执行一次
（6）静态导入包
//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class code {
public static void main(String[] args) {
System.out.println(random());
System.out.println(PI);
}
}
输出结果：
0.5004462577813837 //(0~1的随机数)
3.141592653589793
七、异常处理
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）