Java-复习笔记

1，数据类型
基本数据类型: byte, short, int, long, float, double, char, boolean
引用数据类型: String 数组 集合 对象
自定义数据类型: ?

2，存储空间
寄存器： java 不可访问
栈空间： 存放基本数据类型（效率高，先进后出，空间小，效率次于寄存器）
堆空间： 存放引用数据类型（效率低，大容量，随机分配）

3，变量的运算
Math.sqrt() -> 计算平方根
Math.round(10*number)/10.0 -> 保留小数点1位

4，变量的作用域（一对大括号的范围）

5，基本数据类型的包装类
包装类列表：Byte Short Integer Long Float Double Character Boolean
包装类方法：如 Integer.parseInt(String sInteger) -> String 转换成正数

6，补码（sign与unsign的概念）
＃科学家自定义
g!->符号位可以与其它位一起处理
g!->减法可以变成加法处理
m!->正数 t-> 负数 ＝ 正数的二进制 取反加一
cc!->模＝某种数据类型的正数

7，正数类型
＃四种类型：byte short int long （默认int）
＃byte b2 = b1+3 默认使用int运算，所以会报错

8，浮点类型
单精度float 双精度double
＃默认double （字面量默认）
＃小数时以尾数长度来表示精确度，如pi=3.1415->精确度4位
＃浮点运算就是实数运算
＃double类型保存会有误差->尽量使用int运算。如double d = 2.6->实际上系统保存为2.600000000001

9，字符类型
＃char ->底层使用16位正数，unicode编码来处理字符类型
＃unicode英文字母与数字编码部分与ASCII码相同
?->如何打印unicode码->for{System.out.println(“(char)number”+”:”+number);}

10，转义字符
\n->回车符
\t->制表位字符
\->表示\，\将转回原本的字符
\’->表示’
\”->表示“
\u4e2d -> 表示unicode编码对应的字符（汉字：中），
＃4e2d 转换成10进制 -> 4*Math.pow(16,3)+14*Math.pow(16,2)+2*16+13 = 20013
(char)20013 ->直接打印出“中”

11，类型转换
＃小类型->大类型 ：隐式类型转换（系统自动完成）
＃大类型->小类型 ：强制类型转换（需要程序员手动执行）
＃Integer.toBinaryString()
＃类型大小排列：byte->short->int->long->float->double
＃基本数据类型转换有精度丢失与变价数风险的问题
注意：补位取反，转换成二进制留意最高位，留意类型的精度范围。例：
int i = 257;
byte b = (byte)i; ->由于i的二进制最高位为1，byte默认为负数，会执行补位取反，所以b值为1

＃main函数args值可以通过arg[0]，获取程序开启时输入的参数，亦是java -jar xxx.jar +参数列表 所携带的参数

12，Scanner类的使用
import java.util.Scanner;
Scanner scanner = new Scanner(System.in);
String str;
while (!((str = scanner.next()).equals(“exit”))){
System.out.println(str);
}
//scanner.next();scanner.next().charAt(index);scanner.nextInt();scanner.nextDouble();

13，变量的自增，自减，自乘，自除
int i = 0;
++i -> 先加，再做其他运算
i++ -> 先做其他运算，然后再加
i+=n == i=i+n; ->自增n
- -i ->先减，在做其它运算
i- - ->先做其它运算，再减
i*=n == i=i*n;
i/=n == i=i/n;

14，两个变量的值互换
int a = 100; int b = 10;
方法1: 定义第三变量
方法2: 利用加减法
->a=a+b -> b=a-b -> a=a-b

15，程序错误
＃编译期错误
＃运行期异常
＃逻辑错误 -> 程序没有出错，只是结果不对

16，语句
switch -> 一定要break
关系运算： == != > < >= <=
逻辑运算：
& -> 与运算（长路运算） 如果两边的值是int,则&是两个int的二进制与运算（二进制各个位对比，11为1，10为0），如果两边是关系运算，则进行逻辑运算，例如：4<3 & 5*3>12 -> 1) 计算4<3 = false -> 2)计算5*3>12 = true ->3) false & true = false —>最终得到false
&& -> 与运算（短路运算） 当两个运算结果都true 才true；
＃&&与&的区别—>&&当左边运算结果为false时，则不进行右边的运算
｜ -> 或运算（长路运算） -> 和与运算的规则相同
|| -> 或运算（短路运算）-> 和与运算的规则相同
！ -> 非运算 ->结果取反

＃逻辑运算的优先级: 所有关系运算 > ! > &&/& > ||/|

＃if语句
＃while循环
while循环打印Unicode码实例：
int i = 0;
while(i<=200){
System.out.println(i+”=”+(char)i);
i++;
}

 打印大写字母实例：

//char 类型的字符在Java底层是通过int来处理的
char c = ‘A’;
while(c<=’Z’){
System.out.println(c+”:”+(int)c);
c++;
}

＃do…while 与while 的区别： do…while 是先做再判断，while是先判断再做
＃for循环

＃匿名内部类只能使用外部方法的常量？

＃计算机语言迭代：
第一代：机器语言
第二代：汇编语言
第三代：非结构化语言（Basic） 结构化语言（C）面向对象语言（C++，JAVA，80年代开始流行）

＃ （1991年）Sun开始研发Java
＃JAVA SE ＝ Java Standard Edition
＃JAVA EE ＝ Java Enterprise Edition
＃API ＝ Application Program Interface

Java环境变量的配置
1）JAVA_HOME＝C:\….\jdk1.7.0\ -> 代表JDK的根目录
2）PATH=%JAVA_HOME%\bin -> 代表可以在任意路径下使用Java命令
3）CLASSPATH=%JAVA_HOME%\tools -> javac编译命令需要用到dt.jar & tools.jar 两个文件，所以需要在ClassPath中设置这两个文件下的路径

Math类的方法：
Math.floor() -> 取整数
Math.round(float f) -> 四舍五入为int
Math.abs(-10) -> 取绝对值
Math.pow(3,4) -> 3的4次方
Math.sqrt(120) -> 取平方根
Math.round(3.75*10)/10.0 = 3.8 -> 保留一位小数的方法

类方法／静态方法
＃由static关键字修饰，是静态成员变量，定义在方法外部
＃JVM虚拟机自动初始化，值为

＃属于类的全局变量

＃方法的优点：代码封装在方法中，模块化编程

类和对象的概念

递归方法的使用（遍历手机sdcard，文件夹）
public static int addNum(int num){
if (num ==1){
return 1;
}else {
return num+addNum(num-1);
}
}

＃引用传递的方式
1，创建一个新的方法，传入类，然后修改类内部的变量，这种传入参数称为饮用

＃this关键字
this代表的是当前对象，当前类，可以使用this();->代表当前对象的构造方法

＃static
static声明全局属性
static方法可以通过类名直接调用
只能访问static声明的属性和方法（其它不能访问）

Java的三个基本特征
1，继承／扩展：
＃获得父类的所有功能和属性，按分类来继承／扩展，
＃单继承，多重继承
＃子类不能访问父类的私有成员
＃子类对象的实例化过程：先调用父类的构造方法，再调用字类的构造方法
＃重写父类的方法，被重写的方法权限不能更低
＃super关键字 ->强制调用父类的方法，表示的是父类的方法或者属性

2，封装
＃private私有化属性， public方法访问
3，多态
＃多态性
向上转型（程序自动完成）
父类 父类对象 ＝ 子类实例；
向下转型（强制类型转换）
子类 子类对象 ＝ （子类）父类实例；

＃instanceof -> 判断一个对象是否某类的实例

抽象类和接口
1，final关键字：完结器
＃使用final修饰的类不能被继承
＃使用final修饰的方法不能被重写
＃使用final声明的变量会成为常量，不能被修改
2，抽象类：包含一个抽象方法的类就是抽象类
＃示例
abstract class Abs{
private int age;
public void tell(){

}public abstract void say();public abstract void print();

}

class AbsDemo extends Abs{
@Override
public void say() {

}@Overridepublic void print() {}

}

3，接口：特殊的类，里面全部是由全局常量和公共的抽象方法所组成
＃实例：
interface Inter{
public static final int AGE = 100;
public abstract void tell();

}

class C implements Inter{

@Overridepublic void tell() {    System.out.println("alkjdf");}

}

＃接口可以extend多个接口
＃接口与抽象类的相同点与不同点？
＃接口的使用范例
interface USB{
void start();
void stop();
}
class CDemo {
public static void work (USB u){
u.start();
System.out.println(“工作中”);
u.stop();
}
}
class USBDisk implements USB{
@Override
public void start() {
System.out.println(“USB Disk start”);
}
@Override
public void stop() {
System.out.println(“USB Disk stop”);
}
}
class Printer implements USB{
@Override
public void start() {
System.out.println(“Printer start”);
}
@Override
public void stop() {
System.out.println(“Printer stop”);
}
}
public class main {
public static void main(String[] args) {
CDemo.work(new USBDisk());
CDemo.work(new Printer());
}
}

String字符串
＃实例化方式：String str = “hello”; 或者 String str = new String(“hello”); ->使用第一种方式更省内存空间
＃＝＝比较的是地址，equals()比较的是内容
＃String的内存空间是不可更改的，改变的是堆内存地址的指向
＃常用方法：
length() -> 获取字符串长度
toCharArray() -> 字符串转换成数组
String str = “helloadsfsadfsadf”;
char c[] = str.toCharArray();
for (int i = 0; i < c.length; i++) {
System.out.println(c[i]);
｝
charAt() -> 从字符串中取出特定位置的字符
getBytes() -> 字符串转换成为byte
indexOf() -> 过滤字符串中存在的字符，如果有，则返回字符所在的位置，如果没有则返回-1
trim() -> 去掉字符串的前后空格
subString() ->从字符串中取出子字符串
toUpperCase() -> 转换成大写
toLowerCase() -> 转换成小写
startWith() ->判断字符串开头，判断的条件是一个字符串，长度不限
endsWith() -> 判断字符串结尾，判断的条件是一个字符串，长度不限
replace() -> 替换字符串中的一段字符串或者char

StringBuffer(与String最大的不同，StringBuffer的内存空间是可以更改的)
＃常用方法：
append() -> 追加
insert() -> 插入
replace() -> 替换
indexOf() -> 返回字符串所在的位置
＃实际应用中要用StringBuffer，效率高

StringBuilder
＃一个可变的字符序列，单线程建议使用StringBuilder，效率高，但不利于多线程安全
＃使用方式与StringBuffer一样

异常处理
try{} catch{} finally{}
常见异常：

throws关键字