目录
一、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基础视频,整理的知识点。
指路视频
abstract | assert | boolean | break | byte |
case | catch | char | class | const |
continue | default | do | double | else |
enum | extends | final | finally | float |
for | goto | if | implements | import |
instanceof | int | interface | long | native |
new | package | private | protected | public |
return | strictfp | short | static | super |
switch | synchronized | this | throw | throws |
transient | try | void | volatile | while |
低——————————————————————>高
byte,short,char—> int—> long—> float—> double
(1)算术运算符 + - * / % ++ --
(2)赋值运算符 =
(3)关系运算符 > < >= <= == != instanceof
(4)逻辑运算符 && || ! (注意短路运算)
(5)位运算符 &与 |或 ^异或 ~取反 >>右移除2 <<左移乘2 >>> (二进制)
(6)条件运算符 ? :
(7)扩展赋值运算符 += -= *= /=
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)
(1)java.util.Scanner 可以通过Scanner类来获取用户的输入
(2)基本语法:Scanner s = new Scanner(System.in);
(3)Scanner对象:
//创建一个扫描器对象,用于接受键盘数据 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();
//创建一个扫描器对象,用于接受键盘数据 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();
(1)if
(2)switch
(1)while
(2)do...while
(3)for
//利用for循环打印九九乘法表
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<i;j++){ System.out.print("*"); } System.out.println(); } }
输出结果:
*
***
*****
*******
*********
// break和return的区别 break跳出switch,跳出循环;return 结束方法,返回一个结果
(1)定义:
修饰符 返回值类型 方法名(参数类型 参数名){
...
方法体
...
return 返回值;}
(2)方法调用:对象名.方法名(实参列表)
(1)重载:在一个类中,方法名字相同,而参数列表不同,即参数类型和参数数量不同。返回值类型可以相同也可以不同
(2)方法名称相同时,编译器会根据调用方法的参数个数、参数类型等去逐个匹配,以选择对应的方法,如果匹配失败,则编译器报错。
(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;j<i.length;j++){ if(i[j]>result){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)声明数组变量的语法:
dataType[ ] arrayRefVal; //首选的方法
dataType arrayRefVal[ ]; //效果相同
(2)Java语言使用new操作符创建数组:
dataType[ ] arrayRefVal=new dataType[arraySize];
(3)获取数组长度:array.length
(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)默认初始值
(1)其长度是确定的,数组一旦被创建,它的大小就是不可以改变的
(2)其元素必须是相同类型,不允许出现混合类型
(3)数组中的元素可以是任何数据类型,包括基本类型和引用类型
(4)数组变量属于引用类型,数组也可以看成是对象,数组中的每个元素相当于该对象的成员变量。
数组本身就是对象,Java中对象是在堆中的,因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。
(1)下标的合法区间:[0,length-1],如果越界就会报错;
(2)ArrayIndexOutOfBoundsException:数组下标越界异常!
基本操作
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;i<arrays.length;i++){ sum+=arrays[i]; } System.out.println("sum="+sum); System.out.println("========="); //查找最大元素 int max=arrays[0]; for (int i = 1; i < arrays.length; i++) { if(arrays[i]>max){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 <arrays.length ; i++,j--) { result[j]=arrays[i]; } return result; }
打印数组元素
//打印数组元素 public static void printArray(int[] arrays){ for (int i = 0; i < arrays.length; i++) { System.out.println(arrays[i]+" "); } }
(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
(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]<array[j]){ temp=array[j]; array[j]=array[j+1]; array[j+1]=temp;//交换两个元素通过中间变量,使用三条语句 } } } return array; }
输出结果: [1, 2, 3, 4, 5, 6, 7]
(2)优化排序
(1)面向对象编程本质就是:以类的方式组织代码,以对象的组织(封装)数据
修饰符 返回值类型 方法名(...) {
... //方法体
return 返回值;
}
扩展补充:
break和return的区别 :break跳出switch,跳出循环;return 结束方法,返回一个结果
continue用在循环语句中,用于终止某次循环过程。接着进行下次是否循环的判定
实例化这个类new 对象类型 对象名=对象值
(1)作用:
(2())属性私有 get/set
子类继承父类。所有类的父类是Object类
Java中只有单继承,即一个子类只能有一个父类
引用当前对象的父类。可以使用它访问父类中被覆盖的成员
调用父类的无参构造器,super()空语句必须在子类构造器的第一行; 也可以隐藏不写,默认就有这条语句。
表示对当前对象的引用。
当局部变量和类的成员变量同名时,在局部变量作用区域内成员变量会被隐藏,这时可以使用this来指明类的成员变量
//父类 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 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();//高转低强制转换 } }
System.out.println(X instanceof Y);
//能不能编译通过,就看X和Y之间是否存在父子关系。返回值为true或false
false与报错的区别:
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