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
手动抛出异常,执行异常的抛出动作
当程序中出现逻辑错误,而且不自动创建异常,可以手动新建异常对象,并手动抛

评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值