java基础2

继承

作用：代码重用、复用
单继承
l 一个子类只能继承一个父类
l 一个父类，可以有多个子类

不继承
l 构造方法
l 私有成员（private）

子类实例
l 先新建父类实例
l 再新建子类实例
l 两个实例绑定在一起，整体作为一个实例
l 调用成员时，先找子类，再找父类

1.2 父类的构造方法
新建子类实例时，要先新建父类实例，并先执行父类构造方法
l 默认执行无参构造 super()
l 手动调用父类的有参构造 super(参数)
1.3 super
super.xxxx()
一般在方法重写时，调用父类同一个方法的代码

super()
调用父类的构造方法
必须是首行代码

5 ArrayList
数组列表

封装一个数组，封装了数组的繁琐操作
数组的缺点：
l 长度不可变
l 前面增删数据，数据要来回复制

ArrayList 封装数组：
l 数组默认的初始容量 10
l 放满后，1.5倍增长
l 数组的初始容量可以指定
new ArrayList(1000)

5.1 方法：
add(数据)
在尾部添加数据

get(int i)
获取指定下标位置的数据

remove(int i)
删除指定位置的数据，并返回被删除的值

remove(数据)
找到相等(equals())数据删除，
找到并删除返回true
找不到返回false

size()
数据的数量

自动装箱、自动拆箱

8.1 自动装箱
Integer a = 6;
编译器编译成：
Integer a = Integer.valueOf(6);
8.2 自动拆箱
int i = a;
编译器编译成：
int i = a.intValue();
a = a + 1;
编译器编译成
a = Integer.valueOf(a.intValue() + 1);
l 自动拆箱要当心 null 值

代码

package day1004;

import java.util.ArrayList;

public class Test2 {

public static void main(String[] args) {

ArrayList<Integer> list = new ArrayList<>();

//自动装箱后，加入集合

list.add(6); //list.add(Integer.valueOf(6));  

list.add(2);

list.add(7);

list.add(1);

list.add(99);

list.add(0);

//访问0位置的Integer实例，并自动拆箱

int a = list.get(0);//list.get(0).intValue();

System.out.println(a);  

System.out.println(list.remove(0));

System.out.println(//**删除相等数据，这里要手动装箱**

       list.remove(Integer.valueOf(99)));

System.out.println(list);

}

}

4 final
final 可以修饰
l 常量
l 方法
l 类

7.1 新建Integer 实例
l new Integer(6)
l Integer.valueOf(6)
Integer类中，存在256个缓存的 Integer 实例，范围 -128 到 127
如果指定范围内的值，访问缓存对象
如果指定范围外的值，直接新建实例

5.3 静态初始化块
class A {
static {
静态初始化块，
类被加载到内存时，只执行一次
}
}
静态，属于类，而不属于实例
要用“类”来访问、调用静态成员

5.1 什么时候使用静态
使用原则：能不用就不用
静态是“非面向对象”的语法
使用场景：
l 共享的数据
l 工具方法
Math.sqrt()
String.valueOf()
Integer.parseInt()

常量

static final int MAX_VALUE = 100

l static final
final 不可变，常量
n static 节省内存
l 命名习惯
n 全大写
n 单词之间用下划线连接

对象创建过程

class A {
int v1 = 1;
static int v2 = 2;
static {}
A() {}
}
class B extends A {
int v3 = 3;
static int v4 = 4;
static {}
B() {}
}
new B();
l 第一次用到 A 和 B 类

1. 加载父类，为父类的静态变量分配内存
2. 加载子类，为子类的静态变量分配内存
3. 执行父类静态变量的赋值运算，和静态初始化块
4. 执行子类静态变量的赋值运算，和静态初始化块
   l 再次使用 A 和 B 类
5. 新建父类实例，为父类的实例变量分配内存
6. 新建子类实例，为子类的实例变量分配内存
7. 执行父类实例变量的赋值运算
8. 执行父类构造方法
9. 执行子类实例变量的赋值运算
10. 执行子类构造方法

位运算符

& 位与，上面是1并且下边是1，结果是1
| 位或，上边是1，或者下边是1，结果都是1

^ 异或，不同是1，对同一个值异或两次，得到原值

求反，1变0,0变1

带符号右移位，符号位是0补0，符号位是1补1

不带符号右移位，都补0

<<左移位

向左移动1位，相当于乘2

向右移动1位，相当于除2

00000000000000000000000000110101
00000000000000000000000001101001 &

---

00000000000000000000000000100001

00000000000000000000000000110101
00000000000000000000000001101001 |

---

00000000000000000000000001111101

00000000000000000000000000110101
00000000000000000000000001101001 ^

---

00000000000000000000000001011100

00000000000000000000000001101001 ~

---

11111111111111111111111110010110

00000000000000000000000000110101 >>2

---

00000000000000000000000000001101

10000000000000000000000000110101 >>2

---

11100000000000000000000000001101

10000000000000000000000000110101 >>>2

---

00100000000000000000000000001101

00000000000000000000000000110101 <<2

---

00000000000000000000000011010100

异常的继承结构

Throwable

|- Error 系统级错误

|- Exception 异常，可修复的错误

  |- 其他Exception

  |- RuntimeException

     |- NullPointerException

     |- ArrayIndexOutOfBoundsException

     |- ArithmeticException

     |- NumberFormatException

     |- ClassNotFoundException

     |- ClassCastException

异常

RuntimeException 称为“非检查异常”
编译器不会检查这种异常，不编写处理代码也可以
其他Exception 称为“检查异常”
编译器会检查这种异常，有没有处理代码，没有处理代码，编译通不过
2.5 catch 和 throws
在底层代码出现的错误，一般要向上层抛，在调用路径中，选择一个合适的位置捕获处理
经验不足的情况下，不知道该选择 catch 还是 throws，就要用 throws，不能随便 catch
2.6 throw
手动抛出异常，执行异常的抛出动作
当程序中出现逻辑错误，而且不自动创建异常，可以手动新建异常对象，并手动抛