Java基础知识扫盲点

Java三大版本：java se, java me, java ee, 也叫j2se,j2me,j2ee
Java se: 标准版，基础和核心，开发桌面应用程序。
Java me: 微缩版，主要用于手机程序的开发
Java ee: 企业版，运行在服务器端，提供给用户访问
Java优势：跨平台运行，安全性(比C的指针安全性好)，自动内存管理机制（垃圾回收器），完全面向对象的，代码简单，
Java运行过程： java源文件(.java)经过编译器编译成了字节码文件（.class）,然后在JVM中的“解释器”会把字节码文件解除成本地机器码给本地平台运行。
bin , lib, jre, src.zip(源码,类库文件),
jdk中有jre(运行环境)，jre中有jvm(虚拟机)
开发三步走:编写(.java),编译(.class),运行(

IDE(集成开发环境)： 将开发环境和程序调试集合在一起
记事本开发:
使用记事本编辑.java源程序
使用javac命令编译，生成.class文件
使用java命令运行.class文件
注释：单行 //, 多行/* 开头和/结尾， JavaDoc注释：/*开头和*/结尾
反编译软件:jad, frontend 如：在cmd 中jad.exe路径下执行：D:\Java\jad>jad -s java C:\Users\LIUWENHAI\Desktop\HelloWorld.class, 反编译过来的文件被放在与jad.exe文件下的路径下。
安装自定义Jdk: preference>installed JREs>add>standard VM >directory>选择安装的jdk>finished. Preference>compiler>选择自己的版本（如1.8）>ok.
格式(字体)设置》preference>general>apperance>basic >font或debug>console font
右击》show line number
Java API帮助文档
Java语言中，变量命名要符合一定规则
字、下、美、人、数、骆驼
有意义
不能使用关键字，如public、class
数据类型 大小 取值范围
byte -128 ~ +127
1字节8位
-2147483648（-231） ~ +
int 4字节32位
2147483647（231-1）
-32768 （-215） ~ + 32767
short 2字节16位
（+215-1）
-263 ~ + 263-1
long 8字节64位
1.4E-45 ~ 3.4E+38 , -1.4E-45
float 4字节32位浮点数
~ -3.4E+38
4.9E-324 ~ 1.7E+308, -4.9E-
double 8字节64位浮点数
324 ~ -1.7E+308

常量：（1）常量名通常大写
（2）不同字符使用下划线分隔
（3）只能被赋值一次，通常定义时即对
其初始化

使用Scanner
Scanner input = new Scanner(System.in);
int now = input.nextInt();
String next() 获得一个字符串
int nextInt()获得一个整型数值
double nextDouble()获得一个双精度类型数值
boolean hasNext() 判断是否有输入数据。如果有输入数据，
则返回 true；否则，返回false

自动类型转换和强制类型转换

基本的算术运算：+，-，*，/,%,++,–
复合赋值运算符:+=,-=,*=,/=,%=
关系运算符：
逻辑运算符：&&（短路与），||短路或， ！（非）
优先级：非，与，或
条件运算符（三元运算符）： 条件？表达式1：表达式2
位运算符：

运算符优先级：
单目运算符包括 ！ ~ ++ –，优先级别高
优先级最低的是 赋值运算符 ；
通过（） 控制优先级别
算术运算符>关系运算符 >逻辑运算符

位运算：
按位与： & 两操作数都是1， 结果为1.
按位或： | 两操作数一个是1，结果为1.
按位异或 ^ 两操作数相同，结果为0， 两操作数不同，结果为1。
按位非/取反 ~ 操作数为1， 结果为0。操作说为0，结果为1.
左移 << 右边空位补0
右移 >> 左边空位补最高位即符号位
无符号右移 >>> 左边空位补0
位运算符对操作数以二进制为单位进行运算。
位运算的操作数是整数型，包括 char, byte, int ,short ,long., 结果也是int ，long等整数型。， byte,char, short 会自动转换为int 做运算。

可参考： 位运算之左移右移运算之详解 （https://www.cnblogs.com/yyangblog/archive/2011/01/14/1935656.html）
例子： 计算5&6 得把5（00000101）和6（00000110） 转换为二进制，再进行& （按位与）计算， 结果为4。（00000100 ）。(注释1 为真，0为假，按位与计算规则：全真为真）

计算6<<2 , 得先把6转为二进制，然后把二进制向左移动两位,空出来的两位补0， 结果为24.可以得出结论：一个整数每向左移动1位，其值扩大2倍(6*2*2)。

6>>2右移两位。
得先把6转为二进制，然后把二进制向右移动两位, 110右移两位是1 把后面的10拿掉了,剩下1。

流程控制：
掌握if分支结构
嵌套if控制语句
掌握switch分支结构（条件为等值判断）, break语句 枚举enum
掌握while循环结构（
掌握do-while循环结构
掌握for循环结构和增强for
理解各种循环结构的适用场景
逐步解决指定问题的步骤和方法的一种图形化表
示方法

Java二重循环
九九乘法表
For (int i=1;i<=9;i++){
For (int m=1;m<=I;m++){}
/n}

双重循环次数：外层循环次数*内存循环的次数
Continue：跳出本次循环进入下一次循环
Return 结束方法
随机数：Math.random()
程序调试：设置断点》单步运行，观察变量
F5(单步进入（进入方法) ， F6（单步

数组：是变量，存一组相同数据类型的一组数据。是内存中一连串连续的空间。
数组变量
数组四步走： 声明数组（int[] a）,分配空间（a=new int[5]）,赋值a[0]=8, 处理数据a[0]= （a[0]*10）
基本数据类型：int, double, float, long, char, 这些都是存放在栈内存中。
引用数据类型：数组，包装类.String
Eg: int[] score=new int[5] , score存放在栈内存中，而score指向的5个连续空间则是在堆内存中。
Eg: int [] scores={100,85,89,63}

数组与内存:
Eg: int[] score=new int[5] , score存放在栈内存中，而score指向的5个连续空间则是在堆内存中。

Arrays类操作数组：常用操作：获取最大，最小值，数字排序，插入数字
插入算法：
通过Scanner 输入要插入的数。
数组空间需要加上所插入个数（空位null）
通过比较找到第一次比别人大（小）的位置
标出找到的位置（index）
将插入的数保存到已经标出位置的数组中去，index
原来位置元素依次往后移。

算法：
冒泡排序：口诀：N个数排序小靠前，外层循环 N-1， 内层循环N-1-l .
比较次数一次比一次少（-1），
双循环（控制比较多少轮和可控制比较多少次）
交换数据 （外层循环（轮）：+ 内存循环(次数)=数组的长度-1
外层循环=数组的长度-1；
即内层循环（轮）=数组的长度-1-外层循环；
交换数据： int temp=nums[j]; nums[j]=nums[j+1]; nms[j+1]=temp;

用二重循环将5个数字升序排序
5个数字如何存放
数组，数组.length = 5
控制比较多少轮
外层循环，循环变量 i
控制每轮比较多少次
内层循环，循环变量 j
交换数据

Arrays类: sort, fill, binarySearch, copyOf, toString (bc f st)
Arrays.sort(数组名) 排序
方法名称 说明
boolean equals(array1,array2) 比较array1和array2两个数组是否相等
sort(array) 对数组array的元素进行升序排列
String toString(array) 将一个数组array转换成一个字符串
void fill(array,val) 把数组array所有元素都赋值为val
把数组array复制成一个长度为length
copyOf(array,length)
的新数组，返回类型与复制的数组一致
查询元素值val在数组array中的下标
int binarySearch(array, val)
（要求数组中元素已经按升序排列）

import java.util.Arrays;public class ArraysToolClass {    public static void main(String[] args) {        int[]  scores ={99,9,67,97};        Arrays.sort(scores);        String scoreString =Arrays.toString(scores);        System.out.println(scoreString);        int[] scores2 = {84,38,98,98,87,67};        boolean trueOrFalse = Arrays.equals(scores, scores2);        System.out.println(trueOrFalse);        int[]  scores3 ={99,9,67,97};        Arrays.sort(scores3);        boolean trueOrFalse2 = Arrays.equals(scores, scores3);        System.out.println(trueOrFalse2);        Arrays.fill(scores3, 88);        String scores3FillToString =Arrays.toString(scores3);        System.out.println(scores3FillToString);        System.out.println("before:"+ scores2.length);        int []  scores4 = Arrays.copyOf(scores2, scores2.length*2);        System.out.println("after:"+ scores4.length);        System.out.println(Arrays.toString(scores4));        int index = Arrays.binarySearch(scores2, 98);        System.out.println(index);    }}

一维数组：存的是值 如：int i [] ={1,3}
二维数组：数组中存的还是数组 int [][] scores=new int [4][8],
Scores 就是栈， 【4】【8】这两个是不同的堆，【4】代表第一维数组的空间，【8】代表第二维数组的空间

多维数组很少用（二维居多）

定义并赋值：
写法一：
int [][] scores = new int [][]{{90,85,92.78,99}{76,74,89}{87}};
写法二:
int scores [][] ={{90,85,92.78,99}{76,74,89}{87}};

基本数据类型，形参发生变化时实参不变，
引用数据类型，形成发生变化实参也跟着变化。

对象数组作为参数

Public void modifyScore(Student[] stus);例子：给学员成绩小于60分的同学提高2分。Pulic class ModifyScore{    Public void modifyScore(Student[]  stus){    Boollean flag=false;    For(int i=0;i<stus.length;i++){        If(stus[i].score<60){               Flag=true;              Break;}}If(flag){For(int i=0;i<stus.lentgh;i++){    Stus[i].score+=2;}}}}Pulic static void main(String[] args){ModifyScore ms=new ModifyScore();Student[] stus=new Student[2];Student s1=new Student();S1.name=”tom”,S1.age=18,S1.major=”computer”;S1.score=100;Student[] s2=new Student[2];S1.name=”tom”,S1.age=18,S1.major=”computer”;S1.score=100;Stus[0]=s1;Stus[1]=s2;Ms.modifyScore(stus);For(Student stu:stus){System.out.println(stu.name+stu.score); }}

注：每一个类默认都有一个构造方法 如：public Student();,
这样在实例化时就可以是Student stu=new Student;
构造方法：无返回值，名字和类名一样。可以在构造对象时完成对象属性的（赋值）初始化，
This: 代表当前对象。
This用法：

构造方法之间互相调用（必须是构造方法中的第一条语句）

构造方法重载，
成员变量和局部变量

Java面向对象
面向对象三大特性：封装，继承，多态
抽象类和接口的使用
程序中的异常处理
面向对象实现景区价格计算
使用面向对象描述学校相关类
使用对象数组输出学员年龄

基本数据类型：int double char
引用数据类型： String（包装类，数组,自定义数据类型（*.class）

类和对象的区别：
对象：万物皆对象。用来描述客观事物的一个实体，由一组属性和方法构成。
类：具有相同属性和方法的一组对象的集合。
类是对象的抽象，对象是类的实例（具体）

属性：对象具有的各种特征（成员变量）
方法：对象所执行的操作（成员方法）。有返回值方法和无返回值方法， 带参方法（多个参数之间用逗号隔开）和无参方法。
形参和实参：方法定义处的参数叫形式参数，方法调用处传的值叫实际参数。形参和实参名字可以不一样，但类型和参数个数，顺序必须一样
方法调用：
方法之间允许相互调用，不需要知道方法的具体事项，实现重用，提高效率
方法a直接调用同一个类中的b方法： public void a(){ b() }
A类中方法a 调用B类中 的b 方法： 先创建类对象，再用“.” 调用。
public void a (){ B b = new B(); b.b(); }

方法传参：
定义类的步骤:定义类名,编写类的属性，编写类的方法
创建对象： 类名 对象名=new 类名（）；
引用对象成员：使用“.”。
引用类的属性：对象名.属性
引用类的方法：对象名.方法名().
类图：可以用类图工具（rose,visio,powerdesigner）
Dog 是类名， +是public修饰符,-是private修饰符,name是属性名， String是变量类型， print()是方法名， void是 代表无返回值。

、

面向三大特性：封装，继承，多态。
封装：
例子：狗的属性值为health,如果不封装的话就会暴露给其他人，从而更改了属性值。所以必须通过封装来隐藏其信息，并通过方法来提供对隐藏信息的操作和访问。
封装步骤：设为private,getter/setter(属性的读写),在getter/setter方法中加入控制语句。
Setter赋值，无返回值，
Getter取值，有返回值。
JDK基本包：java.lang(虚拟机自动引入）, java.util（实用类）, java.io（如输入，输出）

如:java.lang (Scanner， Math.random)

类成员的访问修饰符：
private 在同一个类中可以访问，
默认修饰符 在同一类中，同一个包可以访问，
Protected 多用于继承相关(在同一类中，同一个包,子类中可以访问，）
public 到处都可以访问。

Static 修饰符（静态变量和静态方法）：直接通过类名调用 成员（静态）变量，成员（静态）方法，（静态）代码块。

St1时，加载了静态块，会显示(200,300), st2时因静态代码块只加载一次，所以这次没用，
StaticTest.num就是（300）

类的成员变量包括静态变量（类变量）和实例变量
静态变量： static 修饰，在内存中只有一个拷贝，在类内部可以直接访问，其他类中中，通过类名访问。
实例变量：没有static修饰，每创建一个实例就分配一次内存，，可以有多个拷贝，互不影响。
静态方法：可直接通过类名访问，静态方法中不能用this和super，
静态方法中不能访问所属类的实例变量和实例方法（原因和this和super一样）
可以访问类的静态变量和静态方法

为什么静态成员、静态方法中不能用this和super关键字?
(http://blog.csdn.net/u010479322/article/details/51730275)

实例方法：通过实例访问，可以访问所属类的静态变量，静态方法，实例变量，实例方法。
静态方法必须被实现

继承： (单根继承，代码重用)，
1. 把重复的代码（属性和方法）抽取出来形成父类，。 Public class Pet
2. 编写子类，继承父类， public class Dog extends Pet
3. 子类无法继承父类的构造方法，但可以使用super关键字调用父类成员，方法重写父类中的方法而输出子类中自身的信息。

子类访问父类成员(使用super关键字，super代表父类对象，在子类构造方法中调用且必须是第一句，不可以访问父类中定义为private的属性和方法）
访问构造方法：
super（）；
super(name);
访问父类属性，
super.name
访问父类方法
super .print();

什么时候用继承?
符合is -a关系的设计使用继承。
继承是代码重用的一种方式（将子类共有的属性和行为放到父类中）

什么是方法重写?
子类根据需求对从父类继承的方法进行重新编写
重写时，可以使用 super关键字来保留父类的方法
构造方法不能被重写。

方法重写的规则：
方法名相同，
参数列表相同，
返回值类型相同或是其子类
访问权限不能严于父类
父类的静态方法不能被子类覆盖为非静态方法，父类的非静态方法不能被子类覆盖为静态方法。
子类可以定义与父类同名的静态方法，以便在子类中隐藏父类的静态方法。
父类的私有方法不能被覆盖。
不能抛出比父类方法更多的异常

不能被继承的父类成员有哪些？
private 成员，子类与父类不在同包，使用默认访问权限的成员，构造方法

Object类被子类经常重写的方法
toString(),
equals(),
hashCode()
getClass(),获取当前对象所属的类的信息，返回Class对象

抽象方法：r如：public abstract void print(）
抽象方法没有方法体，
抽象方法必须在抽象类中，
抽象方法必须在子类中被实现，除非子类是抽象类

抽象类不能被实例化。但可以创建一个引用变量，其类型是一个抽象类，指向非抽象类的子类实例。
接口也不能被实例化。但可以创建一个引用变量，其类型是一个接口，指向非接口的子类实例。

为什么抽象类不能被实例化？

<父类型><引用变量名> = new <子类型>();
此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法，不是父类的方法
此时通过父类引用变量无法调用子类特有的方法。

抽象类与抽象方法的使用
抽象类中可以没有抽象方法，但包含了抽象方法的类必须被定义为抽象类，
如果子类没有实现父类的所以抽象方法，子类必须被定义为抽象类
没有抽象构造方法，也没有抽象静态方法。
抽象类中可以有非抽象的构造方法，创建子类的实例时可以调用

接口
必须知道的接口特性
接口不能被实例化，
实现类必须实现接口的所以方法，
实现类可以实现多个接口
接口中的变量都是静态常量（public static final )

面向接口编程
三角和是“继承”关系， 三角和虚线是“实现接口”关系

接口中的成员变量，默认都是public static final 的，必须显示初始化，
接口中的方法， 默认都是public abstract
接口没有构造方法，不能被实例化，
一个接口不能实现另一个接口，但可以继承多个其他接口（可以参考“java中接口之间的继承”https://www.cnblogs.com/littlepanpc/p/3616300.html）
一个类必须实现接口抽象方法（implements),除非这个类是抽象类（有点疑问）

一个类只能extends一个父类，但可以implements多个接口。java通过使用接口的概念来取代C++中多继承。与此同时，一个接口则可以同时extends多个接口，却不能implements任何接口。因而，Java中的接口是支持多继承的

抽象类和接口
相同点和不同点
相同点：
代表系统的抽象层
都不能被实例化
都能包含抽象方法
都能包含抽象方法（用于描述系统的服务，不必提供具体实现）

不同点：
在抽象类中可以为部分方法提供默认实现，而接口中只能包含抽象方法，（抽象类便于复用，接口便于代码维护）
一个类只能继承一个直接的父类，但可以实现多个接口。

异常处理

多重异常：先子到父的顺序

多重Catch块
引发多种类型的异常
排列catch语句顺序：先子类后父类
发生异常时按顺序逐个匹配
只执行第一个与异常类型匹配的catch语句

如果后台方法中声明了异常，
方法一：那么当前台调用方法时（或Main方法调用）则必须提前做异常处理或判断。
方法二：普通
方法一：

Syserr : System.err.println();

在catch块 中处理异常
加入用户自定义处理信息，
System.err.println(“出现错误，被除数与除数必须是整数“）

调用方法输出异常信息，
e.printStackTrace();

异常对象常用的方法
void printStackTrace(): 输出异常的堆栈信息。
String getMessage(): 返回异常信息描述字符串，是printStackTrace（）输出信息的一部分。

!异常对象常用的方法2

throw 和throws 的区别
有很明显的区别。
1. 首先，是使用的位置，throws 只能跟在方法名和括号的后面，而 throw 只能出现在方法体内。
2. 其次，throws 是一个声明(它声明这里可能出现异常，但未必一定出现)，而 throw 是一个动作(它抛出也可以说它产生一个异常出现，只要执行到了这个关键字，异常必定出现)。当你使用 throw 抛出(产生)一个异常的时候，如果方法用 throws 抛弃(抛开，这里不理了)异常，那么这个异常将被抛到了”调用这个方法”的地方去。如果这个方法没有用 throws 抛弃异常，那么就需要使用 try…catch 来捕捉异常了。相信你能明白这里所谓的“产生”跟“抛弃”的区别了。产生，就是异常出现的地方。抛弃，就是让异常通过这里去到别的地方，是异常经过的地方。如果你还不明白 throw 具体有什么用，我再举一个简单的例子。例如你做一个程序，需要输入月份的，如果输入了 13 ，那就是无效数据，那这时候你有两种处理方式，第一种就是使用判断语句判断，然后提示；第二种就是抛出一个异常，让上层调用的方法去处理这个输入错误。如果你不明白这种做法的好处，那没关系，以后程序做多了你就会发现的，现在至起码你知道了它有这种用法。

Pubic static void main(String [] args){
Try{
Scanner input=new Scanner(System.in);
Int a =input.nextInt();
}
Catch(Exception e){
e.printStackTrace();//debug（不能给客户看的）
System.out.println(“您输入的不是数字，请你重新输入”);//客户能看到的提示

}
System.out.println(“xxxx”);
}finally{
//处理
System.out.println(“我都有执行”);
}

Or
Catch(Exception e){
e.printStackTrace();//debug（不能给客户看的）
e=new Exception(“您输入的不是数字，请你重新输入”) ;//客户能看到的提示
e.getMessage();
}

System.out.println(ex.getMessage()); 打印异常信息。 如： /by Zero

Final 块唯一不执行的是：System.exit().
System.exit(1); 中断程序，退出Java虚拟机。

\
Exception 类：
Exception
ArithmaticException
ArrayIndexOutofBoundEcxception
ClassnotfoundException
ClassCastExcepiton
NullPointerException
NumberFormatException
IllegalArgumentException

手动抛出异常：
判断性别{
}esle{
Throw new exception(“性别比现是男或女”）；
}

Error和Exception： Error是系统的严重错误引起的， Exception是应用程序抛出和处理的非严重错误。
Checed异常： 程序必须处理该类异常。和Unchecked异常。（RuntimeEcxception)

自定义异常（自定义异常必须先声明异常）
public void setSex(String sex) throws Exception
if(sex.equals(“男”) || sex.equals(“女”））{
this.sex = sex,
} else {
throw new Exception(“性别必须是男或女“）
}