JAVA基础总结
JAVA基础知识点总结
一、基础部分
-
命名规范
-
变量,方法,类名要见名知意
-
类成员变量首字符小写,驼峰命名法
-
局部变量:首字母小写,驼峰命名法
-
类名:首字符大写,驼峰命名法
-
方法名:首字母小写,驼峰命名法
-
包名全部小写,类首字符大写
-
常量全部大写,用下划线分隔
-
-
常量在编译期就要确定值
-
三高问题:高可用,高性能,高并发
-
JAVA特性
- 简单性
- 面向对象
- 可移植性
- 高性能
- 分布式
- 动态性
- 多线程
- 安全性
- 健壮性
-
java运行原理
-
编写代码
-
javac java文件 -->class文件
-
运行class文件
-
-
编程语言运行机制
- 编译(compile)
- c++,c,操作系统
- 解释
- python
- 编译(compile)
-
Java数据类型
- 基本数据类型
- 数值型
- 整形:byte,short,int ,long
- 浮点型:float,double
- 字符型:char
- 布尔型:boolean
- 数值型
- 引用类型:类,接口,数组
注意:
-
一般long类型的数后加L
-
float类型后加F
-
所有的字符本质为数字
2**16=65536,a=97,A=65
- 基本数据类型
-
类型转换
低--------------------------------------------------------------------高
byte,short,char->int->long->float->double
- 强制类型转换:高--低
- 自动转换:低-----高
注意:
- 不能对布尔转换
- 不能把类型转换为不相干的类型
- 转换可能出现内存溢出或者精度问题
-
JDK7新特性,数字之间可以用下划线分割 如:100_00_00
-
Java是强类型语言,每个变量必须声明其类型
-
变量三要素:变量名,变量类型,作用域
-
变量作用域:
- 局部变量:在成员方法内部定义的变量,必须声明初始化值
- 实例变量(成员变量):从属于对象,如果不自行初始化,为这个类型的默认值
- 布尔值默认为false
- 除基本类型外,其他都为null
- 数值型默认值为0
- 类变量(static):从属于类
-
常量:初始化后不再改变
变量的规律:变量类型前都是修饰符,修饰符不存在先后顺序
-
运算符
- 算数运算符:+ - * / % ++ --
- 赋值:==
- 关系:> < >= <= == != instanceof
- 逻辑:&& || !
- 位:& | ^(异或) ~(取反)<< >>>
- 条件:? :
- 扩展赋值:+= -= *= /=
进行算数运算时,有long的结果为long,有double的结果为double,short+byte(其他)=int
-
++ -- 为一元运算符(可以单独运算,区别于+、-)
-
幂运算:Math.pow(2,3) ==>2**3=8
-
逻辑与:两真为真
逻辑或:有真为真
-
加号两侧,一方出现String,把其他转化为String后连接
-
JavaDoc命令用来生成自己的Api文档
- @author作者名
- @version版本号
- @Since知名最早使用的jdk版本
- @param参数名
- @return返回值
- @throws异常抛出
-
JAVA流程控制
- Jdk5新特性,scanner获取用户输入
Scanner scan=new Sanner(System.in);
-
凡是属于Io流的类,要即使关掉流
scan.close();
-
next():
- 必须输入值
- 有空格,自动去除
- next不能带有空格
-
nextlint():
返回回车前的所有字符
21、打印99乘法表
//打印99乘法表
for (int j = 1; j <=9 ; j++) {
for (int i = 1; i <= j; i++) {
System.out.print(j + "*" + i + "=" + (j * i)+" ");
}
System.out.println();
}
-
break跳出循环,continue跳出本次循环
-
质数:大于1的自然数中,除了1和它本身以外不再有其他因数的自然数
-
打印101-105之间的质数
public static void main(String[] args) { int count = 0; outer: for (int i = 101; i < 150; i ++) { for (int j = 2; j < i / 2; j++) { if (i % j == 0) continue outer; } System.out.print(i+ " "); } }
-
计算0-100之间的奇数和,偶数和
public static void main(String[] args) { int oddSum = 0; //用来保存奇数的和 int evenSum = 0; //用来存放偶数的和 for(int i=0;i<=100;i++){ if(i%2!=0){ oddSum += i; }else{ evenSum += i; } } System.out.println("奇数的和:"+oddSum); System.out.println("偶数的和:"+evenSum); }
-
用while或for循环输出1-1000之间能被5整除的数,并且每行输出3个
public static void main(String[] args) { for(int j = 1;j<=1000;j++){ if(j%5==0){ System.out.print(j+"\t"); } if(j%(5*3)==0){ System.out.println(); } } }
-
重载:在同一个类中,相同函数名,参数不同
- 规则:方法名必须相同
- 参数列表必须不同(个数,类型,排列顺序)
- 方法返回值类型可以想通,可以不同
- 在同一个勒种
-
可变参数(...)
- 在参数类型后+省略号
- 一个方法只能指定一个可变参数,必须是方法的最后一个参数
- 任何普通参数必须在它之后申明
-
递归(自己调用自己)
-
递归头:什么时候不能调用自身的方法(如果没有递归头,则陷入死循环)
-
递归体:什么时候调用自身的方法(阶乘)
-
public static void main(String[] args) { System.out.println(f(5)); } public static int f(int n) { if (1 == n) return 1; else return n*f(n-1); }
-
-
二、数组
数组的定义
- 数组是相同类型数据的有序集合
- 数组表述的是相同类型若干数据,按照一定先后顺序组合
- 每一个数据称为一个数组元素,每个数组元素可以通过下标来访问
数组的四个基本特点:
- 其长度是确定的。数组一旦被创建,它的大小就是不可以改变的。
- 其元素必须是相同类型,不允许出现混合类型。
- 数组中的元素可以是任何数据类型,包括基本类型和引用类型。
- 数组变量属引用类型,数组也可以看成是对象,数组中的每个元素相当于该对象的成员变量。数组本身就是对象,Java中对象是在堆中的,因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。
数组三大初始化:
- 静态初始化:
int[] a=[1,2,3]
- 动态初始化:
int[]a=new int[10]
- 默认:数组为引用类型,数组一经初始化分配空间,被隐式初始化
arrays.sort():排序(升序)
三、内存分析
- 声明的时候并没有实例化任何对象,只有在实例化数组对象时,JVM才分配空间,这时才与长度有关。因此,声明数组时不能指定其长度(数组中元素的个数),例如: int a[5]; //非法
- 声明一个数组的时候并没有数组被真正的创建。
- 构造一个数组,必须指定长度
四、排序算法
冒泡排序算法的原理:
- 比较相邻的元素。如果第一个比第二个大,就交换他们两个。
- 对每一对相邻元素做同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的
数。 - 针对所有的元素重复以上的步骤,除了最后一个。
- 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
class Bubble {
public int[] sort(int[] array) {
int temp = 0;
// 外层循环,它决定一共走几趟 //-1为了防止溢出
for (int i = 0; i < array.length - 1; i++) {
int flag = 0; //通过符号位可以减少无谓的比较,如果已经有序了,就退出循环
//内层循环,它决定每趟走一次
for (int j = 0; j < array.length - i - 1; j++) {
//如果后一个大于前一个,则换位
if (array[j + 1] > array[j]) {
temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
flag = 1;
}
}
if (flag == 0) {
break;
}
}
return array;
}
public static void main(String[] args) {
Bubble bubble = new Bubble();
int[] array = {2, 5, 1, 6, 4, 9, 8, 5, 3, 1, 2, 0};
int[] sort = bubble.sort(array);
for (int num : sort) {
System.out.print(num + "\t");
}
}
}
选择排序算法的原理:
- 是每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到排序序列的末尾。以此类推,直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。
class SelectSort{
public int[] sort(int arr[]) {
int temp = 0;
for (int i = 0; i < arr.length - 1; i++) {// 认为目前的数就是最小的, 记录最小数的下标
int minIndex = i;
for (int j = i + 1; j < arr.length; j++) {
if (arr[minIndex] > arr[j]) {// 修改最小值的下标
minIndex = j;
}
}// 当退出for就找到这次的最小值,就需要交换位置了
if (i != minIndex) {//交换当前值和找到的最小值的位置
temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
}
return arr;
}
public static void main(String[] args) {
SelectSort selectSort = new SelectSort();
int[] array = {2, 5, 1, 6, 4, 9, 8, 5, 3, 1, 2, 0};
int[] sort = selectSort.sort(array);
for (int num : sort) {
System.out.print(num + "\t");
}
}
}
五、面向对象
- break结束方法,返回一个结果
- 一旦定义有参构造,必定以无参构造
1. 构造器
- 和类名相同
- 无返回值
构造器作用:
- new本质为调用构造方法
- 初始化对象的值(alt+insert)
2.三大特性
2.1 封装
- 优点:
- 提高安全性,保护数据
- 隐藏代码实现细节
- 统一接口
- 可维护性增强
2.2继承(ctrl+h继承树)
- 调用父类构造器必须放在第一行
- 方法的调用只和左边的数据类型有关
2.2.1方法重写
- 方法名相同
- 参数列表相同
- 范围可以扩大,不能缩小
- 抛出异常可以缩小,不能扩大
2.3多态
多态特征
- 多态是方法的多态,属性没有多态
- 父类子类有联系
- 存在继承关系,方法要重写
- 父类引用指向子类
不可重写的情况
- static属于类,不属于实例,静态方法不可重写
- final修饰不可重写
- private修饰不可重写
tips:
- 父类引用指向子类,不能调用子类独有的方法(对象能执行哪些方法,主要看左边的类型)
多态的条件
- 有继承关系
- 子类重写父类的方法
- 父类引用指向子类的对象
instanceof判断两个类是否存在父子关系
补充
- 父类引用指向子类对象
- 把子类转为父类,向上转型
- 父--子,向下转型(强制类型转换)
- 方便方法调用,减少重复代码
六、static关键字
- 非静态可访问静态方法
- 静态方法只能调用静态方法,不可以调用普通方法
代码块,静态代码块执行顺序
- 静态代码块
- 匿名代码块
- 构造方法
七、抽象类
- 抽象方法,只写方法名,不用实现
- 抽象类所有的方法,继承了它的子类必须实现它的方法
- 如果子类是抽象类,name交给子子类
注意
- 抽象类不能new,只能靠子类实现
- 抽象方法必须在抽象类中
- 抽象类可以写普通的方法
八、接口
定义:只有规范,约束和实现分离,面向接口编程
- 接口中所有的定义默认是抽象的
- 可实现多个接口,用 “ ,” 隔开
注意:
- 约束
- 定义方法,让不同的人实现
- 接口不能被实例化