Java基础知识

1. 计算机基础知识

1. 计算机的硬件分成5大组成部件：运算器、控制器、存储器、输入设备和输出设备
2. 计算机软件按照其功能划分为系统软件与应用软件

计算机语言的分类:

1. 机器语言
   机器语言是直接用二进制代码指令表达的计算机语言,指令是用0和1组成的一串代码,它们有一定的位数,并分成若干段,各段的编码表示不同的含义
2. 汇编语言
   汇编语言是使用一些特殊的符号来代替机器语言的二进制码,计算机不能直接识别,需要用一种软件将汇编语言翻译成机器语言
3. 高级语言C,C++,C#,JAVA
   使用普通英语进行编写源代码,通过编译器将源代码翻译成计算机直接识别的机器语言,之后再由计算机执行

常用快捷键

键盘功能键

快捷键
Tab
Shift
Ctrl
Alt
空格
Enter
Window
上下左右键
PrtSc(PrintScreen)屏幕截图

键盘快捷键

快捷键	功能
Ctrl+A	全选
Ctrl+C	复制
Ctrl+V	粘贴
Ctrl+X	剪切
Ctrl+Z	撤销
Ctrl+S	保存
Ctrl+Y	撤销的逆向操作
打开DOS控制台	win+r–cmd–回车

常见的DOS命令讲解

快捷键	功能
d:	回车 盘符切换
dir(directory)	列出当前目录下的文件以及文件夹
cd	(change directory)改变指定目录(进入指定目录)
cd…	退回到上一级目录
cd:	退回到根目录
cls	(clear screen)清屏
exit	退出dos命令行
md	(make directory)创建目录
rd	(remove directory)删除目录
del	(delete)删除文件,删除一堆后缀名一样的文件*.txt

2. java语言基础知识

java语言的历史

1. SUN(Stanford University Network,斯坦福大学网络公司)
2. 詹姆斯·高斯林（James Gosling）

Java分类

1. J2SE(Java 2 Platform Standard Edition)标准版
   是为开发普通桌面和商务应用程序提供的解决方案,该技术体系是其他两者的基础,可以完成一些桌面应用程序的开发
2. J2ME(Java 2 Platform Micro Edition)小型版
   是为开发电子消费产品和嵌入式设备提供的解决方案
3. J2EE(Java 2 Platform Enterprise Edition)企业版
   是为开发企业环境下的应用程序提供的一套解决方案,该技术体系中包含的技术如 Servlet、Jsp等,主要针对于Web应用程序开发

java语言的优点

Java优点
简单性
编译性
面向对象
高性能
分布式处理
多线程
健壮性
动态
结构中立
安全性
开源
可跨平台,通过安装一个Java虚拟机(JVM Java Virtual Machine)即可

JRE是什么

1. 包括Java虚拟机(JVM Java Virtual Machine)和Java程序所需的核心类库等,如果想要运行一个开发好的Java程序,计算机中只需要安装JRE即可。
2. 简单说:JRE=JVM+类库

JDK是什么

1. JDK是提供给Java开发人员使用的,其中包含了java的开发工具,也包括了JRE。所以安装了JDK,就不用在单独安装JRE了。
2. 简单说JDK=JRE+JAVA的开发工具。

java语言习惯性规则

1. 大括号要对齐,并且成对写
2. 左大括号前面有空格
3. 遇到左大括号要缩进,Tab
4. 方法和程序块之间加空行让程序看起来清晰
5. 并排语句之间加空格,例如for语句
6. 运算符两侧加空格

Java关键字

1. 什么是关键字
   被Java语言赋予特定含义的单词
2. 关键字的特点
   组成关键字的字母全部小写
3. 关键字的注意事项
   goto和const作为保留字存在,目前并不使用

Java标识符

1. 什么是标识符
   就是给类,接口,方法,变量等起名字时使用的字符序列
2. 标识符的组成规则
   英文大小写字母
   数字字符
   $和_
3. 标识符注意事项
   不能使用关键字
   不能数字开头

Java命名规则

1. 包
   最好是域名倒过来,要求所有的字母小写
2. 类或者接口
   如果是一个单词首字母大写
   如果是多个单词每个单词首字母大写(驼峰标识)
3. 方法或者变量
   如果是一个单词全部小写
   如果是多个单词,从第二个单词首字母大写
4. 常量
   如果是一个单词,所有字母大写
   如果是多个单词,所有的单词大写,用下划线区分每个单词

Java常量

1. 什么是常量
   在程序执行的过程中其值不可以发生改变
2. Java中常量的分类
   字面值常量
   自定义常量
3. 字面值常量的分类

常量类型	含义
字符串常量	用双引号括起来的内容
整数常量	所有整数
小数常量	所有小数
字符常量	用单引号括起来的内容,里面只能放单个数字,单个字母或单个符号
布尔常量	较为特殊,只有true和false
空常量	null

Java变量

1. 什么是变量
   在程序执行的过程中,在某个范围内其值可以发生改变的量
2. 变量的定义格式
   数据类型 变量名 = 变量值;

3. java数据类型

二,八,十,十六进制

1. 二进制的数据表现形式
   由0,1组成。以0b(b可以大写也可以小写)开头(JDK1.7版本可以表示二进制了)
2. 八进制的数据表现形式
   由0,1,…7组成。以0开头
3. 十进制的数据表现形式
   由0,1,…9组成。整数默认是十进制的
4. 十六进制的数据表现形式
   由0,1,…9,a,b,c,d,e,f(大小写均可)。以0x开头
5. 任意进制到十进制的转换原理
   系数：就是每一位上的数据
   基数：X进制,基数就是X
   权：在右边,从0开始编号,对应位上的编号即为该位的权
   结果：把系数*基数的权次幂相加即可
6. 输出不同进制表现100的数据

进制	语法
二进制	0x100
八进制	0100
十进制	100
十六进制	0x100

基本数据类型(无需new,在静态区直接可用)

1. 注意:float表示的数据范围比long的范围要大,它们底层的存储结构不同
   
   1. long：2^63-1
   2. float：3.4* 10^38 > 2* 10^38 > 2* 8^38 = 2* 2^3^38 = 2*2^114 > 2^63-1

基本数据类型	字节数	长度
byte	占一个字节	-128到127
short	占两个字	-2^15~2^15-1
int	占四个字节	-2^31~2^31-1
long	占八个字节	-2^63~2^63-1
float	占四个字节	-3.403E38~3.403E38 单精度
double	占八个字节	-1.798E308~1.798E308 双精度
char	占两个字节	0~65535
boolean	理论上是占八分之一个字节,因为一个开关就可以决定是true和false了	但是java中boolean类型没有明确指定大小

基本数据类型间的转换

1. Java中的默认转换规则
   取值范围小的数据类型与取值范围大的数据类型进行运算,会先将小的数据类型提升为大的,再运算
2. 混合运算
   
   1. 进行混合运算的时候,byte,short,char不会相互转换,都会自动类型提升为int类型,其他类型进行混合运算的是小的数据类型提升为大的
   2. 具体规则:byte,short,char --> int --> long --> float --> double
3. 强制转换

//如果超出了被赋值的数据类型的取值范围得到的结果会与你期望的结果不同
int a = 10;
byte b = 20;
b = a + b;
b = (byte)(a + b);

4. java运算符

基础知识

1. 什么是运算符
   就是对常量和变量进行操作的符号
2. 运算符的分类

运算符分类	包含
算术运算符	+,-,*,/,%,++,–
赋值运算符	=,+=,-=,*=,/=,%=
比较(关系或条件)运算符	==,!=,>,>=,<,<=
逻辑运算符	&,|,^,!,&&,||
位运算符	&,|,^,~ ,,>,<<
三目(元)运算符	(关系表达式) ? 表达式1 : 表达式2;

算术运算符

1. %运算符
   
   1. 当左边的绝对值小于右边绝对值时,结果是左边
   2. 当左边的绝对值等于右边或是右边的倍数时,结果是0
   3. 当左边的绝对值大于右边绝对值时,结果是余数
   4. %运算符结果的符号只和左边有关系,与右边无关
   5. 任何一个正整数%2结果不是0就是1可以用来当作切换条件
2. ++和–运算符
   
   1. 单独使用：
      放在操作数的前面和后面效果一样。(这种用法是我们比较常见的)
   2. 参与运算使用：
      
      1. 放在操作数的前面,先自增或者自减,然后再参与运算
      2. 放在操作数的后面,先参与运算,再自增或者自减

逻辑运算符

1. 逻辑运算符一般用于连接boolean类型的表达式或者值。
2. 表达式：就是用运算符把常量或者变量连接起来的符合java语法的式子。
   
   1. 算术表达式：a + b
   2. 比较表达式：a == b(条件表达式)
3. &&和&(|和||)的区别
   
   1. 最终结果一样。
   2. &&具有短路效果。左边是false,右边不执行。
   3. &是无论左边是false还是true,右边都会执行
   4. 因此&&和||效率更高,开发中更常用

位运算符

位运算符	功能
&	有0则0
|	有1则1
^	相同则0,不同则1,一个数据对另一个数据位异或两次,该数本身不变
~	按位取反
<<	左移,左边最高位丢弃,右边补齐0;右移,最高位是0,左边补齐0;最高为是1,左边补齐1
>	无符号右移 无论最高位是0还是1,左边补齐0

三元运算符

1. 条件运算符的格式(关系表达式) ? 表达式1 : 表达式2;
   关系表达式返回true则执行表达式1,否则执行表达式2
2. 与if语句的区别
   
   1. 三元运算符实现的,都可以采用if语句实现,反之不成立
   2. 三元运算符是一个运算符,运算符操作完毕就应该有一个结果,而不是一个输出

5. java控制语句

使用键盘录入数据(Scanner)

import java.util.Scanner;//导入util下的Scanner包
public class demo{
    Scanner sc = new Scanner(System.in);
    int x = sc.nextInt();//输入int类型赋值给x
}

遍历Map

Map<String, String[]> map = request.getParameterMap();
//遍历map
for (Entry<String, String[]> imap : map.entrySet()) {
    String key = imap.getKey();
    String[] value = imap.getValue();
    System.out.println("key:"+key+","+Arrays.toString(value));
}

if选择语句

1. if选择语句
2. 比较表达式true则执行语句体,否则不执行
   if(比较表达式) {
   语句体;
   }
3. 比较表达式true则执行语句体1,否则执行语句体2
   if(比较表达式) {
   语句体1;
   }else {
   语句体2;
   }
4. 依次判断比较表达式,返回false则判断下一条比较表达式
   if(比较表达式1) {
   语句体1;
   }else if(比较表达式2) {
   语句体2;
   }else if(比较表达式3) {
   语句体3;
   }
   …
   else {
   语句体n+1;
   }

switch选择语句

1. 计算表达式的值,与case后的值12…比较,找到相等值的时候执行相应语句体,找不到则执行默认语句体n+1
   switch(表达式) {
   case 值1：
   语句体1;
   break;
   case 值2：
   语句体2;
   break;
   …
   default：
   语句体n+1;
   break;
   }
2. 使用switch时的注意事项
   
   1. case后面只能是常量，不能是变量，多个case后面的值不能相同
   2. default可以省略，但是不建议，因为它的作用是对不正确的情况给出提示
   3. break最后一个可以省略,其他最好不要省略,会出现一个现象：case穿透
   4. default不一定要在最后,可以在任意位置,但是建议在最后
   5. switch语句的结束条件:遇到break或执行到switch的右大括号
3. if和switch在什么时候使用
   
   1. switch建议判断固定值的时候用
   2. if建议判断区间或范围的时候用

for循环语句

1. 执行次序:初始化表达式->条件表达式->true[->false->结束循环]->循环体->循环后的操作表达式->条件表达式->…
   for(初始化表达式;条件表达式;循环后的操作表达式) {
   循环体;
   }
2. 常见用法:求和,统计,连续获取数据等

while循环语句

1. 执行次序:初始化语句->判断条件语句->true[->false->结束循环]->循环体语句->控制条件语句->判断条件语句->…
   初始化语句;
   while(判断条件语句) {
   循环体语句;
   控制条件语句;
   }

do…while循环语句

1. 执行次序:初始化语句->循环体语句->控制条件语句->判断条件语句->true[->false->结束循环]->循环体语句->控制条件语句->判断条件语句->…
   初始化语句;
   do {
   循环体语句;
   控制条件语句;
   }while(判断条件语句);

for,while,do…while三者区别

1. do…while循环至少执行一次循环体,而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句
2. 想在循环结束后，继续使用控制条件的那个变量，用while循环，否则用for循环
3. 不知道用谁就用for循环,因为变量及早的从内存中消失，可以提高内存的使用效率

死循环

1. 两种最简单的死循环格式
   while(true){…}
   for(;;){…}

break,continue和return的区别

关键字	功能	工作域
break	是跳出循环	只能在switch和循环中
continue	是终止本次循环继续下次循环	只能在循环中
return	是结束方法	不是结束循环

6. java方法

修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
    方法体语句;
    return 返回值;
}

方法重载

1. 在同一个类中，方法名相同，参数列表不同,与返回值类型无关
2. 参数列表不同是指：
   
   1. 参数个数不同
   2. 参数类型不同
   3. 参数的顺序不同(算重载,但是在开发中不用)
3. 方法中的参数
   
   1. 无参数
   2. 基本类型参数
   3. 引用类型参数
4. 可变参数(jdk1.5以上版本支持)
   
   1. 必须在方法的形参列表的最后，语法 数据类型…参数名
   2. 在方法中可变参数 使用数组解析方法
   3. 对应实参的个数是任意的

7. java数组

什么是数组

1. 存储同一种数据类型多个元素的集合,也可以看成是一个容器
2. 既可以存储基本数据类型，也可以存储引用数据类型
3. 数组用于存储同种数据类型的多个值

数组的格式

数据类型[] 数组名 = new 数据类型[数组的长度];

数组的初始化

1. 就是为数组开辟连续的内存空间，并为每个数组元素赋予值
2. 动态初始化–只指定长度，由系统给出初始化值
   int[] arr = new int[5];
3. 静态初始化–给出初始化值，由系统决定长度

动态初始化的格式：

数据类型[] 数组名 = new 数据类型[数组长度];

静态初始化的格式：

数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
数据类型[] 数组名 = {元素1,元素2,…};

使用数组时的常见java报错

1. ArrayIndexOutOfBoundsException:数组索引越界异常
   原因：你访问了不存在的索引
2. NullPointerException:空指针异常
   原因：数组已经不在指向堆内存了,而你还用数组名去访问元素

常用的数组代码

• 遍历数组每个元素

       public static void print(int[] arr) {
            for (int i = 0;i < arr.length ;i++ ) {
                System.out.print(arr[i] + " ");
            }
        }

• 获取数组中元素的极值

       public static int getMax(int[] arr) {
            int max = arr[0];
            for (int i = 1;i < arr.length ;i++ ) {          //从数组的第二个元素开始遍历
                if (max < arr[i]) {                         //如果max记录的值小于的数组中的元素
                    max = arr[i];                           //max记录住较大的
                }
            }return max;
        }

• 将数组中元素的顺序反转

      public static void reverseArray(int[] arr) {
            for (int i = 0;i < arr.length / 2 ; i++) {
                //arr[0]和arr[arr.length-1-0]交换
                //arr[1]和arr[arr.length-1-1]交换
                //arr[2]和arr[arr.lentth-1-2]
                //...
                int temp = arr[i];
                arr[i] = arr[arr.length-1-i];
                arr[arr.length-1-i] = temp;
            }
        }

• 根据元素下标查找对应元素(下标从0开始,从左向右)

       public static char getWeek(int week) {
            char[] arr = {' ','一','二','三','四','五','六','日'};     //定义了一张星期表
            return arr[week];                                           //通过索引获取表中的元素
        }

• 根据元素查找其在数组中第一次出现所对应的索引位置(下标)

      public static int getIndex(int[] arr,int value) {
            for (int i = 0;i < arr.length ;i++ ) {              //数组的遍历
                if (arr[i] == value) {                          //如果数组中的元素与查找的元素匹配
                    return i;
                }
            }
            return -1;
        }

二维数组(作为了解,java中常用集合)

1. 语法:
   int[][] arr = new int[3][2];//表示创建了一个3行2列的二维数组arr
2. 其他格式
   数据类型 数组名[][] = new 数据类型[m][n];
   数据类型[] 数组名[] = new 数据类型[m][n];
   数据类型[][] 数组名 = new 数据类型[m][n];
   m不能为0
   n可以为0
3. 创建时直接赋值
   int[][] arr =new int[][] {{1,2,3},{4,5},{6,7,8,9}};
4. 二维数组中元素的遍历

      int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};
        for (int i = 0;i < arr.length ;i++ ) {          //获取到每个二维数组中的一维数组
            for (int j = 0;j < arr[i].length ;j++ ) {   //获取每个一维数组中的元素
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }

8. java面向对象编程

面向对象特征

1. 封装(encapsulation)
2. 继承(inheritance)
3. 多态(polymorphism)

面向对象思想特点

1. 是一种更符合我们思想习惯的思想
2. 可以将复杂的事情简单化
3. 将我们从执行者变成了指挥者

我们如何描述现实世界事物

1. 属性 就是该事物的描述信息(事物身上的名词)
2. 行为 就是该事物能够做什么(事物身上的动词)

Java中最基本的单位是类,Java中用class描述事物也是如此

1. 成员变量 就是事物的属性
2. 成员方法 就是事物的行为

类和对象的概念

1. 类 是一组相关的属性和行为的集合
2. 对象 是该类事物的具体体现

封装

1. 封装(encapsulation)
   是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
2. 封装好处
   
   1. 隐藏实现细节，提供公共的访问方式
   2. 提高了代码的复用性
   3. 提高安全性。
3. 封装原则
   
   1. 将不需要对外提供的内容都隐藏起来。
   2. 把属性隐藏，提供公共方法对其访问。

继承

1. 继承(extends)
   让类与类之间产生关系,子父类关系,”is a”
2. 继承的优点
   
   1. 提高了代码的复用性
   2. 提高了代码的维护性
   3. 让类与类之间产生了关系，是多态的前提
3. 继承的缺点
   
   1. 类的耦合性增强了
   2. 开发的原则：高内聚，低耦合
      
      1. 耦合：类与类的关系
      2. 内聚：就是自己完成某件事情的能
4. java中继承的用法
   
   1. Java只支持单继承，不支持多继承
   2. Java支持多层继承(继承体系)
   3. 子类只能继承父类所有非私有的成员方法和成员变量)
   4. 子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法
   5. 使用条件:如果有两个类A,B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承
   6. 子类中所有的构造方法默认都会访问父类中空参数的构造方法

多态

1. 多态(polymorphism)
   在java中一个对象具有多种形态的方式称为多态
2. 多态形成的条件
   
   1. 要有继承（包括接口的实现）
   2. 要有重写
   3. 父类引用指向子类对象
3. 多态的分类
   
   1. 编译时多态（设计时多态）
      方法重载,编译时就能确定执行哪个方法的情况
   2. 运行时多态(提到多态默认为运行时)
      JAVA运行时系统根据调用该方法的实例的类型来决定选择调用哪个方法则被称为运行时多态,运行时才能决定是运行父类还是子类的方法
4. 运行时多态中存在instanceof运算符,比较对象类型是否一致

//如果运行时，使用类的强制转换，有可能是转换失败，jvm抛出的异常ClassCastException
       public void info(Person p) {
        //运行时 多态
        //java运行时可以通过 变量类判断 运算符 instanceof
            if(p instanceof Student) {
                System.out.println("确实是一个学生类");
                //强制转换
                Student s=(Student)p;
            }
        }

成员变量与局部变量的区别

1. 在类中的位置不同
   
   1. 成员变量 在类中方法外,是属于类的
   2. 局部变量 在方法定义中或者方法声明上
2. 在内存中的位置不同
   
   1. 成员变量 在堆内存(成员变量属于对象,对象进堆内存)
   2. 局部变量 在栈内存(局部变量属于方法,方法进栈内存)
3. 生命周期不同
   
   1. 成员变量 随着对象的创建而存在，随着对象的消失而消失
   2. 局部变量 随着方法的调用而存在，随着方法的调用完毕而消失
4. 初始化值不同
   
   1. 成员变量 有默认初始化值,比如int为0;booleanw为false
   2. 局部变量 没有默认初始化值，必须定义，赋值，然后才能使用
5. 变量名可以相同
   局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。

静态变量与成员变量的区别

1. 所属不同
   静态变量—-类变量
   成员变量—-对象变量
2. 内存位置不同
   静态变量—-存储于方法区的静态区
   成员变量—-存储于堆内存
3. 内存的生成和释放不同
   静态变量—-随着类的加载而加载，随着类的消失而消失
   成员变量—-随着对象的创建而存在，随着对象的消失而消失
4. 被调用方式不同
   静态变量—-可以通过类名调用，也可以通过对象调用
   成员变量—-只能通过对象名调用

引用数据类型

1. 基本数据类型
   byte,short,int,long,float,double,boolean,char
2. 引用数据类型
   数组,类,接口,枚举

构造方法Constructor

1. 构造方法概述和作用
   给对象的数据(属性)进行初始化
2. 构造方法格式特点
   
   1. 方法名与类名相同(大小也要与类名一致)
   2. 没有返回值类型，连void都没有
3. 构造方法与普通方法的区别
   
   1. 构造方法必须与类同名，不能写返回类型
   2. 在创建对象时调用构造方法
   3. 普通方法，在创建对象后通过对象.普通方法()
   4. 构造方法可以调用普通方法
   5. 普通方法不能调用构造方法
4. 构造方法相互调用
   必须在构造方法的第一条语句中通过this关键调用
5. 注意事项
   
   1. 如果我们没有给出构造方法，系统将自动提供一个无参构造方法
   2. 如果我们给出了构造方法，系统将不再提供默认的无参构造方法,这个时候，如果我们还想使用无参构造方法，就必须自己给出

关键字static(静态的)

1. static关键字的特点
   
   1. 随着类的加载而加载
   2. 优先于对象存在
   3. 被类的所有对象共享
   4. 共性用静态,特性用非静态
   5. 可以通过类名调用
   6. 其实它本身也可以通过对象名调用。
   7. 推荐使用类名调用。
   8. 静态修饰的内容一般我们称其为：与类相关的，类成员
2. 注意事项
   
   1. 静态方法不能使用this
   2. 静态是随着类的加载而加载，this是随着对象的创建而存在。
   3. 静态比对象先存在。
   4. 静态方法只能访问静态的成员变量和成员方法;非静态都可以访问

关键字final(最终的)

修饰	特点
修饰类	类不能被继承
修饰变量	变量就变成了常量，只能被赋值一次
修饰方法	方法不能被重写
修饰基本类型	值不能被改变
修饰引用类型	地址值不能被改变,对象中的属性可以改变

main方法

public static void main(String[] args) {}

参数	特点
public	被jvm调用，访问权限足够大
static	被jvm调用，不用创建对象，直接类名访问
void	被jvm调用，不需要给jvm返回值
main	一个通用的名称，虽然不是关键字，但是被jvm识别
String[] args	以前用于接收键盘录入的

代码块

• 在Java中，使用{}括起来的代码被称为代码块。

代码块分类	简介
局部代码块	在方法中出现；限定变量生命周期，及早释放，提高内存利用率
构造代码块	在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
静态代码块	在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次,一般用于加载驱动
同步代码块

this和super的区别

1. this和super都代表什么
   
   1. this 代表当前对象的引用,谁来调用我,我就代表谁
   2. super 代表当前对象父类的引用
2. this和super的使用区别
   
   1. 调用成员变量
      
      1. this.成员变量 调用本类的成员变量,也可以调用父类的成员变量
      2. super.成员变量 调用父类的成员变量
   2. 调用构造方法(必须出现在构造方法的第一条语句上)
      
      1. this(…) 调用本类的构造方法
      2. super(…) 调用父类的构造方法
3. 调用成员方法
   
   1. this.成员方法 调用本类的成员方法,也可以调用父类的方法
   2. super.成员方法 调用父类的成员方法

方法重写与方法重载的区别

1. 语法
   
   1. 方法重写—-@Override
   2. 方法重载—-@Overload
2. 使用区别
   
   1. 方法重写：子类中存在的与父类中方法名一样,参数列表也一样的方法。与返回值类型有关,返回值类型是一致(或者是子父类)的
   2. 方法重载：本类中存在的方法名一样，参数列表不同的方法。与返回值类型无关,可相同也可不同
3. 注意事项
   
   1. 子类对象调用方法的时候：先找子类本身，再找父类
   2. 访问修饰符都可修改

9. Java修饰符

1. 修饰符分类
   权限修饰符：private，默认的，protected，public
   状态修饰符：static，final
   抽象修饰符：abstract
2. 修饰符的使用条件
   
3. 权限修饰符的权限
   

10. 类与接口

抽象类

1. 为什么要有抽象类
   在类的层级结构中位于顶层的类，希望有些方法子类，必须重写父类中的该方法，将该方法变成抽象(abstract)的
2. 注意事项
   
   1. 一个类中如果包含抽象方法的话，该类必须是抽象类
   2. 一个抽象类中可以没有抽象方法
   3. 抽象类不能直接实例化
3. 抽象类可以有构造函数
   因为你不可以创建抽象类的实例，所以构造函数只能通过构造函数链调用，在子类中可以通过super调用抽象父类中定义的构造方法
4. 抽象类可以实现接口
   通过使用关键字implements来实现接口。因为它们是抽象的，所以它们不需要实现所有的方法
5. 抽象类不可以被final修饰
   因为java抽象类不能被实例化，所以继承抽象类是声明该类的唯一作用，final修饰的类不能被继承
6. 抽象类可以包含static方法
   因为Java中的static方法是不可以被重载的

(匿名)内部类

1. 内部类访问特点
   
   1. 内部类可以直接访问外部类的成员，包括私有
   2. 外部类要访问内部类的成员，必须创建对象
      外部类名.内部类名 对象名 = 外部类对象.内部类对象;
2. 匿名内部类(内部类的简化写法)
   
   1. 前提:存在一个类或者接口(具体或抽象)
   2. 本质:是一个继承了该类或者实现了该接口的子类匿名对象
   3. 语法
      new 类名或者接口名(){
      重写方法;
      }

uml类(关联关系的分类)

1. 泛化(Generalization): 表示is-a的关系，是对象之间耦合度最大的一种关系，子类继承父类的所有细节
2. 实现（Realization): 在类图中就是接口和实现的关系
3. 依赖(Dependency): 对象之间最弱的一种关联方式，是临时性的关联
4. 关联(Association): 对象之间一种引用关系
   
   1. 一般关联关系
   2. 聚合关系(Aggregation): 表示has-a的关系，是一种不稳定的包含关系。较强于一般关联,有整体与局部的关系,并且没有了整体,局部也可单独存在
   3. 合成关系(Composition): 表示contains-a的关系，是一种强烈的包含关系

接口

1. 语法
   [访问修饰符] interface 接口名{};
2. 访问修饰符
   public或默认
3. 注意事项
   
   1. 接口中只包含常量和抽象方法声明
   2. 定义接口，不能直接实例化
4. Java抽象类和接口的区别
   
   1. 抽象类特点
      
      1. 可以包含构造方法,普通成员变量,非抽象的普通方法,静态方法,静态成员变量
      2. 抽象方法的访问类型可以是public,protected和默认类型,静态成员变量的访问类型可以是任意
      3. 一个类只能继承一个抽象类
5. 接口特点
   
   1. 不能包含构造方法,普通成员变量,非抽象的普通方法,静态方法
   2. 抽象方法或静态成员变量只能是public类型的，并且默认即为public abstract类型
   3. 一个类只能继承一个抽象类
   4. 一个类可以实现多个接口