java基础技术总结：
☞为什么Java语言能够跨平台？
Java虚拟机---Java Virtual Mechine---JVM。所有的Java程序是运行在Java虚拟机上的，Java虚拟机屏蔽了不同操作系统之间的差异性，使得相同的Java程序能够在不同的操作系统上运行，从而实现了Java语言的跨平台。
Java语言是跨平台的，但是Java虚拟机不是跨平台的
☞关键字
是只在Java中被赋予了特殊含义的单词
在Java中一共有53个关键字，其中51个在用，还有2个目前没有使用，称之为保留字---const常量，goto跳转语句
所有的关键字都是小写的。
练习：判断是否是一个奇数
练习： >=90 A >= 80 B >= 60 C < 60 D
java 中逻辑运算符&与&&，|与||
&&短路与，运算规则和&完全一样，但是&&有短路特性,如果&&之前的运算结果确定为false，则后边的表达式就不再运算。
对于||而言，如果前边的表达式的结果为true，则后边的表达式就不再运算
一、&与&&的异同点。
相同点：二者都表示与操作，当且仅当运算符两边的操作数都为true时，其结果才为true，否则为false。
不同点：在使用&进行运算时，不论左边为true或者false，右边的表达式都会进行运算。如果使用&&进行运算时，当左边为false时，右边的表达式不会进行运算，因此&&被称作短路与。
二、|与||的异同点。
相同点：二者都表示或操作，当运算符两边的操作数任何一边的值为true时，其结果为true，当两边的值都为false时，其结果才为false。
不同点：同与操作类似，||表示短路或，当运算符左边的值为true时，右边的表达式不会进行运算。
break和continue区别
break：用于选择或者循环语句中，表示结束当前一层语句
continue：用于循环语句中，表示跳出当前循环继续下次循环
这两个关键字必须结合相应的语句使用，单独存在没有意义，因此单独存在的时候编译报错
Java中支持对循环进行标号---要求看懂即可。
System.out.print();--废话，废话不允许存在--编译报错
int i = 5;
while(true){}
System.out.println(i);--这句话编译报错---因为永远执行不到
循环支持标号形式
当需要一次性跳出多层循环的时候，可以使用标号形式。但是不推荐。降低了程序的阅读性
数据类型的转换
内存
Java将内存分为了五块：栈内存，堆内存，方法区，本地方法栈，寄存器
栈内存
变量是存储在栈内存中的。
存储变量，执行代码块的。变量存储在栈内存中不会自动赋予初始值，变量使用完成之后立即移除出栈内存，释放空间
堆内存
存储的是对象。对象在堆内存中会自动的赋予一个默认值。
---初始值：byte/short/int---0, long---0L
float---0.0f, double---0.0, char---‘\u0000’, boolean---false, 所有的引用类型的默认值全部都是null
对象在使用完成之后，不会立即移除，而是在不定的某个时刻被回收。
----------------------------------------------------------------------------
----------------------------------------------------------------------------
----------------------------------------------------------------------------
----------------------------------------------------------------------------
----------------------------------------------------------------------------
ArrayIndexOutOfBoundsException---数组下标越界异常---编译没有问题---说明明语法没有问题---逻辑上或者事实上不符合--运行出错
NullPointorException---空指针异常---编译没有问题---对于null而言，不能做任何操作
int i = 5; int j = i;
注意：对于基本类型而言，传值传的实际的数据；对于引用类型而言，传值传的是地址。
数组元素排序
冒泡排序:
for(int i = 1 ; i < arr.length ; i++){ //控制轮数
for(int j = 1; j <= arr.length - i; j++){ //控制每轮的次数，以及下标
if(arr[j - 1] > arr[j] ){
int temp = arr[j - 1];
arr[j - 1] = arr[j];
arr[j] = temp;
}
}
}
选择排序:
for(int i = 1; i < arr.length ; i++){ //控制轮数和起始下标
for(int j = i - 1; j < arr.length; j++){ //控制次数，后边那一位的下标的变化
if(arr[i - 1] > arr[j]){
int temp = arr[i - 1];
arr[i - 1] = arr[j];
arr[j] = temp;
}
}
}
快速排序、希尔排序、堆排序
import java.util.Arrays;
Arrays.sort(数组); //只能升序排列---从小到大
String s = Arrays.toString(arr);---将数组中的元素依次取出拼接成了一个字符串
6. 查找元素的位置
A. 遍历
B. 折半查找---要求数组有序---时间复杂度：O(log2n)
无序数组---for循环
有序数组---折半查找
7. 反转数组---头尾交换
利用新的数组，也可以利用两个变量来同时操作数组的两端
注意：如果访问的下标不存在，会出现ArrayIndexOutOfBoundsException---数组下标越界异常---编译的时候没有报错---因为语法无错。---所以编译检查的是语法问题
数组的扩容---数组的复制
System.arraycopy(要复制的数组，要复制的数组的起始位置，被复制到的数组，新数组中放置的起始位置，要复制的元素的个数);
System.arraycopy(arr,3,arr2,2,5);---从arr下标为3的位置开始复制，复制5个元素到arr2中，从arr2的下标为2的位置开始依次存放
数组 = Arrays.copyOf(要扩容的数组, 扩容之后的大小);---表面上看起来对数组的长度做了改变，实际上数组已经发生了变化，已经是一个新的数组---数组在扩容完成之后，堆内存的地址已经发生了改变
Arrays.copyOf(arr,len);
int[] arr2 = new int[len];
if(len < arr.length){
System.arraycopy(arr,0,arr2,0,len);
} else {
System.arraycopy(arr,0,arr2,0,arr.length);
}
T[] arr2; //数据类型在Java底层动态获取的
arr2 = new T[长度]; //T---表示泛型
if(长度 >= 数组.length){
System.arraycopy(arr,0,arr2,0,arr.length);
} else {
Sysetem.arraycopy(arr,0,arr2,0,长度);
}
arr = arr2;
补充扩展：
1. int i = 1 / 0;---编译没有问题---运行---ArithmeticException---算术异常
在Java中小数允许除以0，结果是Infinity/NaN---Not a Number---NaN和任何值都不相等，即使是本身，也不相等。
2. 尽量减少使用小数作为控制条件----因为小数在计算机中不能够精确存储
3. strictfp---在函数执行过程中，小数是以80位二进制进行存储的，但是函数完成之后，依然使用double类型存储最终的结果---最终的结果依然是64位二进制小数
杨辉三角
1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 arr[i][j] = arr[i - 1][j] + arr[i - 1][j - 1];
输入一个数n，输出前n行 //从控制台获取行数 Scanner s = new Scanner(System.in); int row = s.nextInt(); //根据行数定义好二维数组，由于每一行的元素个数不同，所以不定义每一行的个数 int[][] arr = new int[row][]; //遍历二维数组 for(int i = 0; i < row; i++){ //初始化每一行的这个一维数组 arr[i] = new int[i + 1]; //遍历这个一维数组，添加元素 for(int j = 0; j <= i; j++){ //每一列的开头和结尾元素为1，开头的时候，j=0，结尾的时候，j=i if(j == 0 || j == i){ arr[i][j] = 1; } else {//每一个元素是它上一行的元素和斜对角元素之和 arr[i][j] = arr[i -1][j] + arr[i - 1][j - 1]; } System.out.print(arr[i][j] + "\t"); } System.out.println(); }
方法的重载
当同一个类内出现了方法名一致而参数列表不同的方法的时候，构成了方法的重载。---方法名一致而参数列表不同---方法名+参数列表---方法签名
方法在调用的时候会进行最优匹配---找参数类型最符合的进行匹配。---如果进行方法的重载，尽量重载所有的情况，以防出现调用混乱的情况
方法的递归
函数调用自己本身就形成了递归。
public static int sum(int number){
if(number <= 0){
return 0;
}
return number + sum(number - 1);
}
面向对象
面向对象是相对面向过程而言的。面向过程注重的是过程，强调的是动作；面向对象注重的是对象，只要找到了对应的对象，那么就自然拥有了对象所具有的一切功能
根据一类事物进行抽取，将这一类事物用一个类表示，同时将这一类事物的共有特征抽取成属性，将这一类事物的共有行为抽取成了方法---将这些属性和方法放到了一个类中，用这个类表示这一类的事物---类是对象的抽取
/概括
根据类利用new关键字去创建该类对象的对象（实例），并且可以为对象的对应属性赋值，也可以去调用对应的方法---对象是类的实例化/具体化
对象在内存中的存储
对象在传值的时候传递的是地址
成员变量和局部变量之间有什么不同？
1. 定义位置：成员变量是定义在类内方法外；局部变量是定义在方法或者语句内部
2. 作用域：成员变量作用在整个类中；局部变量只能在定义的方法或者语句内部使用
3.内存存储位置不同：成员变量是随着对象的创建存储到了堆内存中，并且在堆内存中自动的赋予默认值；局部变量在方法或者语句执行的时候存储到了栈内存在中，不会自动给值
4. 生命周期不同：成员变量是随着对象的创建而加载到堆内存中，随着对象的回收而释放；局部变量在方法或者语句执行的时候才会创建，随着方法或者语句的结束而立即移除出栈内存
面向对象的特征
封装 继承 多态（抽象）
封装
封装的体现形式：
函数，属性的私有化---为了防止在类外直接操作属性的时候给属性赋值一些不符合常量的值，因此将属性私有化，提供了对外的访问方法来间接的操作属性---属性私有化保护了数据的安全性
优势：提高了代码的复用性，提高了代码的安全性
继承
如果一些类中有一些共有的方法和属性，将这些方法和属性提取出来放到一个新的类中，然后利用extends关键字让原来的类和新的类产生联系--这个关系称之为继承。新的类称之为父类（超类，基类），原来的类称之为子类（派生类）
在Java中支持的是单继承---一个子类只能有一个父类，而一个父类可以有多个子类
子类通过继承父类可以使用父类中的一些方法和属性
Java中支持多层继承
单继承和多继承的优劣性比较：
多继承在代码的复用性上要优于单继承
优点：提高了代码的复用性，可以避免方法调用的混乱--使方法的调用更加安全
方法的重写
当父子类中产生了方法签名完全一致的方法的时候，构成了方法的重写/覆盖
注意：方法的重写遵循 两等两小一大 这五个要求
1. 方法签名要求完全一致
2. 如果父类中方法的返回值类型是基本类型/void/最终类，子类中重写的方法的返回值类型必须一致
3.如果父类方法的返回值类型是引用数据类型，那么子类重写的方法的返回值类型是父类方法返回值类型的子类或者是本身
4. 子类方法的权限修饰符的范围要大于等于父类方法的权限修饰符的范围
1428
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
