java笔记01(基础、面向对象、异常)

1、关键字(也叫保留字)，49个，true，false，null不是关键字

2、字符类型(char)在内存中占有两个字节，严格来说字符类型也算是整数类型

3、一个汉字两个字节，所以一个字符只能存放一个汉字

4、java中使用的是Unicode字符码系统

5、转义字符可以用单引号、双引号引起来

6、如果一个数以0开头，代表8进制数，以0x开头，代表16进制

7、使用浮点型数据时，默认类型是double，整数默认是int类型
long a = 12312L；byte b1 = 1;是没问题的，自动砍掉前面三个字节

8、如果保存到小数的精度超出了计算机到精度，会自动四舍五入
byte，short，char→int→long→float→double
低的自动向高的转换，高的转换为低的要加强制类型转换符

9、byte，short，char之间不会互相转换，他们三者计算时首先转换为int类型

10、”+”运算符两侧的操作数中只要有一个是字符串(String)类型，系统会自动将另一个操作数转换为字符串，然后进行连接

11、当进行打印时，无论任何类型，都自动转换为字符串再打印出来，任何数据类型碰到String类型后，都向String类型转换

12、取模的时候，结果的符号取决于第一个数

13、b=a++; 先将a赋给b，然后再自加

14、异或^,相同为flase(0)，其他为true(1)

15、break:结束循环，继续执行循环下的语句
continue：结束本次循环，继续下一次循环

16、数值都有范围：
最大值+1 = 最小值
最小值-1 = 最大值

17、&& 短路与：左边表达式为假，右边表达式就不进行运算了
& :无论左边是真是假，右边都运算

18、&,| 存在到价值：作为位运算符而存在，&（按位与）|（按位或）

19、操作数必须是2的正数次幂：

左移<<: 就是该数乘以2的移动位数次幂
右移>>: 就是该数除以2的移动位数次幂

无论最高位是什么，都补0；没有逻辑左移
最高位补什么由原有数据的最高位而定，最高位是1就补1，是0补0

20 a异或b两次，结果还是a；

21 位运算高效率 2*8，2左移3位；2<<3;

22 交换两个数：
n = n + m;
n = n - m;
m = n - n;

n = n ^ m;
m = n ^ m;
n = n ^ m;

23 在计算机中数据的运算都采用补码的方式！！；正数的补码就是其原码，负数的补码就是其原码取反加1

24 负数逻辑右移变正数，而且这个正数很大

25 switch 只能应用于 byte short int char;

26 如果i只为循环增量而存在的话，for循环比while循环节省内存

27 累加思想：通过变量记录住每次变化的结果，一个变量 + 一个循环

28 计数器思想：通过一个变量记录住数据的状态变化

29 for循环嵌套：外循环控制行数，内循环控制一行中元素的个数

尖朝上：改内循环条件；
尖朝下：改内循环初始值；

30 分解问题，将大问题最小化

31 如何定义一个函数：

1.明确函数的返回值类型
2.明确函数的参数列表

32 函数是复用性的最基本的体现，主函数是用来调用函数的；函数里面肯定有return，只是没有返回值的时候省略了；函数遇到return就停止了！

对于函数，如果写了不调用，相当于没写！

33 重载只和参数列表有关系!!和返回值类型没关系，也就是不管返回值类型当定义的功能相同，但参与运算的参数不用时，那么就只定义一个函数名称，而通过参数列表的不同来区分多个同名函数

看有没有重载，只要看虚拟机能否辨别这两个函数

34 数组：
int[] x = new int[3];

凡是new出来的实体都在堆空间里面，实体包括：数组和对象

35 堆内存中的变量都有默认初始化值；

栈.自动释放，堆.垃圾回收；
只有引用数据类型才能使用null

36 求最值、排序、选择排序、冒泡排序、查找

冒泡排序：相邻的两个元素进行比较，如果符合条件就换位

37 往数组里存的不是int、不是double、而是数组，就称二维数组
二维数组就是数组中有数组

38 int[][] arr = new int[3][4]; 定义了一个名称为arr的二维数组，该数组中有三个一维数组，每一个一维数组中有四个元素

System.out.println(arr[0].length); 打印二维数组中第一个一维数组的长度

实际上二维数组中arr[0]中存的是其中一维数组的地址

39

一维数组定义：int[] x; int x[];
二维数组定义：int[][] y; int[] y[]; int y[][];

40

面向过程：移动窗口、关闭窗口、最小化窗口；
面向对象：窗口移动、窗口关闭、窗口最小化；

冰箱打开、关闭，只有冰箱最清楚，谁最清楚这个动作，就定义到谁里面去
有执行者转变成指挥者；名词提炼法：将名词定义成对象

找对象，建立对象，使用对象，维护对象的关系！

41 匿名对象：当对对象的方法只调用一次时，可以用匿名对象来完成；
可以将匿名对象作为实际参数进行传递

42 封装：

隐藏对象的属性和实现细节，仅对外提供公共访问方式,你没必要知道内部是怎么实现的，你只要用就行了

加入了getter和setter函数后，就可以在函数里面加上条件，比如在setAge函数内加上年龄大于0的判断

43
成员变量在堆内存中，都有默认初始值，局部变量分配在栈内存中，无默认初始值
局部变量不初始化是不能参与运算的

44

构造函数不能定义返回值，不可以写return；用于给对象初始化

对象一建立 就会调用与之对应的构造函数,就会运行构造函数

当定义了构造函数，默认的构造函数就不存在了

45

构造代码块作用：给对象进行初始化；对象一建立就运行，而且优先于构造函数执行

和构造函数区别：构造代码块是给所有对象进行统一初始化，而构造函数是给对应的对象初始化

构造代码块中定义的是不同对象的共性

46 this关键字

this:用于区分局部变量和成员变量重名的情况
this：代表本类的对象
哪个对象在调用this所在的函数，this就代表哪个对象

Person(String name) { name = name; }
里面的两个name都是局部变量,要指明前一个name是成员变量的话，得写成this.name=name;

47 this语句

this语句：用于本类中构造函数之间互相调用，比如：this(name);
this语句只能定义在构造函数的第一行（初始化动作要先执行）

48 static修饰符：

用于修饰成员变量、成员方法
当成员被static修饰后，该成员除了可以被对象调用，还可以直接被类名调用

49 static特点：

1.随着类的加载而加载，随着类的消失而消失
2.优先于对象存在
3.被所有对象共享

50 成员变量和类变量的区别：

1.存放位置，类变量随着类的加载而存在于数据区中，成员变量随着对象的建立而存在于堆内存中；
2.类变量生命周期最长，随着类的消失而消失，成员变量随着对象的消失而消失

51 静态使用注意事项：

1.静态方法只能访问静态成员
2.静态方法中不可以定义this、super关键字，因为静态优先于对象存在；

52 静态有利有弊：

利处：对对象的共享数据进行单独空间的存储，节省空间,没有必要每个对象中存储一份

弊端：生命周期过长；静态虽好，只能访问静态

53 静态代码块

随着类的加载而执行，只执行一次！用于给类进行初始化，并优先于主函数执行 static {}

54 Person p = new Person(“zhang”,18);怎么执行的？

1.加载Person.class到内存中
2.执行该类中的静态代码块
3.在堆内存中开辟空间，分配内存地址
4.在堆内存中建立对象的特有属性，并进行默认初始化
5.对属性进行显示初始化
6.对对象进行构造代码初始化
7.对对象进行对应的构造函数初始化
8.将内存地址赋给栈内存中的p变量

55 单例设计模式：

1. 将构造函数私有化；
2. 在类中创建一个本类对象；
3. 提供一个方法可以获取到该对象；

分为懒汉式和饿汉式；建议使用饿汉式，懒汉式不安全！

56 继承：is a
找到共性内容，不断抽取出来；java只支持单继承；

57 Super关键字

代表父类对象的引用
如果子类、父类中出现非私有的同名成员变量时
子类要访问本类中的变量用this
子类要访问父类中的同名变量用super
super的使用和this的使用几乎一致

58 覆盖/重写：

当子类出现和父类一模一样的函数时，注意哦：是一模一样的函数
子类对象调用该函数，会运行子类函数的内容
如同父类的函数被覆盖一样
被子类覆盖的方法不能缩小访问权限
方法覆盖从private变为default/public不算是方法覆盖

class Father {
   void show() { System.out.println("fu lei");}
}

class Son extends Father {
   void show() {
    //调用了父类的show方法
    super.show(); 
    System.out.println("zi lei");}
}

59 子类构造函数：

1. 在对子类对象进行初始化时，父类构造函数会先于子类构造函数执行，先有父母再有儿女
   所以在实例化子类对象前，需要先将父类中的对象进行初始化
2. 子类的构造函数默认第一行有一条隐式的语句 super();
3. super(); ：会访问父类空参数的构造函数，而且子类中所有的构造函数默认第一行都是super();
   4.子类调用父类构造函数: super();
   5.子类调用父类普通函数：super.函数名();
   6.当父类中没有空参数的构造函数时，子类必须手动通过super()语句形式来指定要访问父类的构造函数

60 final关键字

作为一个修饰符
1. 可以修饰类、函数、变量
2. 被final修饰的类不可以被继承
3. 被final修饰的方法不能被覆盖
4. 被final修饰的变量是常量，只能赋值一次；

61 抽象类(abstract)的特点：

1. 抽象方法一定定义在抽象类中；
2. 抽象方法和抽象类都必须被abstract修饰；
3. 抽象类中的抽象方法要被使用，必须由子类覆盖其所有的抽象方法后，建立子类对象调用
4. 如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类

62 模版方法设计模式：

在定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去，由该类的子类去完成

63 接口特点：

1. 接口中的成员都是public的
2. 接口里面全是抽象方法
3. 接口中的成员都有固定的修饰符
   常量：public static final
   方法：public abstract
4. 子类必须将接口中的抽象方法全部实现后，才能创建对象，否则子类也是抽象类
5. 接口可以被类多实现

64 不支持多继承的原因：

父类方法有重名的情况，子类调用不知道调用的是哪个
而接口不同，接口中的方法都是抽象方法，无方法体；

65

类与类之间是继承关系，类与接口之间是实现关系，接口与接口之间是继承关系

注意：接口之间可以多继承；因为接口都没有方法体；

接口降低了耦合性、提高了扩展性；

66

有一功能是一部分对象的共性，当又不是所有对象的共性，那么就可以把这一功能定义在接口中，有该功能的就实现该接口；

继承：is-a
接口：like-a

基本功能定义在类中，扩张功能定义在接口中

67

equals方法比较的是两个对象的值是否相同
str1.equals(str2);

68 多态：

Animal c = new Cat(); 父类引用指向子类对象；
此时c只能调用父类Animal中存在的方法，但执行的是子类Cat中的方法
如果想要调用子类Cat特有的方法 ：Cat c1 = (Cat)c;

69 动态绑定

实际当中new的是什么类型就调用谁的方法；
定义：是指是执行期间判断所引用对象的实际类型，根据其实际类型调用其相应的方法；

70 在多态中，静态成员函数的特点：

无论编译和运行，都参考左边

71 在多态中成员函数的特点：

成员函数在多态调用时，编译看左边，运行看右边

72 在多态中，成员变量(包括静态)的特点：

无论编译和运行，都参考左边

73 Object类 equals() toString() 方法；

所有对象都有哈希值，所以Object类中有hashCode()方法；

74 内部类(内置类、嵌套类)

1. 内部类可以直接访问外部类中的成员，包括私有
   因为内部类中持有外部类的引用，格式：外部类名.this
2. 外部类要访问内部类，必须建立内部类对象；
3. Out.In in = new Out().new In() 创建内部类对象；
4. 当内部类在成员位置上，就可以被成员修饰符所修饰，比如private static
5. 当内部类中定义了静态成员，该内部类必须是静态的；

当描述事物时，事物内部还有事物，该事物就用内部类来描述；

75 String 、Math、还有Integer、Double……等这些封装类重写了Object中的equals()方法，让它不再比较句柄（引用），而是比较对象中实际包含的整数的值，即比较的是内容。

76 异常：

程序在运行时出现不正常情况
对于严重问题，java通过Error类进行描述，一般不编写代码对其处理
对于非严重问题，java通过Exception类进行描述，可以进行处理

Error和Exception具有共性，可以向上抽取，抽取出来就叫做Throwable类

77 异常的处理：

try{
    需要被检测的代码
}catch(异常类 变量){
    处理方式
}finally{
    一定会执行的语句
}

没有异常 catch不会运行

被调用的函数抛出了异常，调用着必须处理异常或者再次抛出异常(运行时异常除外)

多异常，catch并列处理

78 自定义异常：

项目中出现特有的问题，并未被java描述并封装成对象；
需要继承Exception，因为异常类和异常对象都被抛出，这个可抛性是Throwable这个体系中独有特点

class FushuException extends Exception {

    FushuException(String meg) {
        super(meg);
    }
}

class AB {
    public int div(int a,int b) throws FushuException{
        if(b<0)
            throw new FushuException("除数不能是负数！");
        return a/b;
    }
}

public class Demo3 {
    public static void main(String[] args) {
        AB ab = new AB();
        try {
            int x = ab.div(4, -1);
            System.out.println(x);
        } catch (FushuException e) {
            e.printStackTrace();
            System.out.println("负数异常");
        }
    }
}

79 throws和throw的区别：

throws使用在函数上，后面跟的是异常类，可以跟多个、用逗号隔开
throw 使用在函数内，后面跟的是异常对象

80 RuntimeException 运行时异常

如果在函数内抛出该异常，函数上可以不用声明
如果在函数上声明了该异常，调用者可以不用处理

81 异常分两类：

编译时异常(可处理)
运行时异常(不可处理)

82

throw写在函数里面，后面不能再写代码了，因为throw意味着结束，和return相当

83

finally代码块：定义一定执行的代码，通常用于释放资源

84

catch是用于处理异常，如果没有catch就代表该异常没有被处理过，如果该异常是检测时异常，那么必须在函数上声明；

85

子类覆盖父类中抛出了异常的方法时，子类只能抛出和父类一样的异常或者该异常的子类异常，或者不抛异常

如果父类的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常，如果子类方法发生了异常，就必须要在子类方法中进行try catch处理；

86 异常的好处：

1. 将问题进行封装
2. 将正常流程代码和问题处理代码相分离，方便于阅读

87 子类方法覆盖父类方法时，不能缩小访问权限

88

java中的包就是文件系统中的文件夹
package pack;
类名的全名是：包名.类名；

89 权限修饰

public → protected → 默认 → private ；