学习记录
2024.4.15，记录一些关于学习java过程的，防止后续遗忘，方便回顾
一、数据类型
C语言
基本数据类型：
整型：short（2B） int(4B) long(8B)
浮点型：float（4B） double（8B）
字符型：char（1B）
构造数据类型：
结构体（struct）、数组（arry）、共用体（union）枚举（enum）
指针数据类型（*）、空类型（void）
共用体（union）举例：
//比如成绩不同的表示方法 95分 A档 95.0分 union的大小与最大的数据类型相同，一次只能一个变量有值
union{
int a;
float b;
char c;
}
枚举（enum）举例：
enum EN{
a,//0
b,//1
c//2
};
JAVA
基本数据类型：
整型：byte(1B) short（2B） int(4B) long(8B)//byte不同
浮点型：float（4B） double（8B）
字符型：char（2B）//不同点 char a='男'
布尔型：boolean（4B）
引用数据类型：
类：class
接口：interface
数组：array[]
枚举：enum
记录：record
JAVA，String为引用数据类型，俗称字符串，String s="abc"
判断String A，B是否相同用A.equal（B）方法，不是A==B
c语言中，使用的是char arr[N]来当字符串，char arr[]="abc",默认在字符串后面添加'\0'，
不可以arr="abc"(arr为地址常量)，可以使用函数操作：
strcpy (A,B)：把B中字符复制到A中去
strcat (A,B)：把B拼接到A后面去
strlen（A）：计算A的长度 不包含 '\0'
strcmp（A，B）：AB长度比较 A>B 结果大于0，反之<0,相等=0.
二、标识符
C语言
字母 数字 下划线 ,数字不可以开头。不能是关键字
JAVA
由26个英文字母大小写，0-9 ，_或
$组成
数字不可以开头。
不可以使用关键字和保留字，但能包含关键字和保留字。
Java中严格区分大小写，长度无限制。
标识符不能包含空格。
JAVA命名规范：
包名：多单词组成时所有字母都小写：xxxyyyzzz。
例如：java.lang、com.atguigu.bean
类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz 大驼峰
例如：HelloWorld，String，System等
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz 小驼峰
例如：age,name,bookName,main,binarySearch,getName
常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
例如：MAX_VALUE,PI,DEFAULT_CAPACITY
三、流程控制语句
顺序、分支（if-else、switch-case）、循环（for、do{}while、while{}）
C语言
字母数字下划线 ,数字不可以开头。不能是关键字
JAVA
由26个英文字母大小写，0-9 ，_或
$组成
数字不可以开头。
不可以使用关键字和保留字，但能包含关键字和保留字。
Java中严格区分大小写，长度无限制。
标识符不能包含空格。
JAVA命名规范：
包名：多单词组成时所有字母都小写：xxxyyyzzz。
例如：java.lang、com.atguigu.bean
类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz 大驼峰
例如：HelloWorld，String，System等
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz 小驼峰
例如：age,name,bookName,main,binarySearch,getName
常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
例如：MAX_VALUE,PI,DEFAULT_CAPACITY
break语句用于终止某个语句块的执行
{ ……
break;
……
}
break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块
label1: { ……
label2: { ……
label3: { ……
break label2;
……
}
}
}
四、输入输出
C语言
输出：printf（"%d\n",a）;
printf（"%10.2f\n",b）;//占10个位置，包含小数点，小数后面占两位（.2f说明小数后面占两位，长度变化）
输入：scanf("%d%s%l%f%c",a,b,c,d,f);//除了%c都可以分离‘ ’和‘\n’
JAVA
输出：System.out.println("samll");
输入：Scanner 变量1= new Scanner(System.in);
数据类型 变量2=变量1.next() / nextXxx();//根据需要安排不同数据类型；可以先定义，后赋值！
变量1.close();//关闭资源
键盘输入代码的四个步骤：
1. 导包：`import java.util.Scanner;`
2. 创建Scanner类型的对象：`Scanner scan = new Scanner(System.in);`
3. 调用Scanner类的相关方法（`next() / nextXxx()`），来获取指定类型的变量
4. 释放资源：`scan.close();
例如：
Scanner scanner = new Scanner(System.in);//System.in默认代表键盘输入
//③根据提示，调用Scanner的方法，获取不同类型的变量
System.out.print("请输入你的网名：");
String name = scanner.next();//.next():为String类型
System.out.print("请输入你的年龄：");
int age = scanner.nextInt();
System.out.print("请输入你的体重：");
double weight = scanner.nextDouble();
System.out.print("你是否单身（true/false)：");
boolean isSingle = scanner.nextBoolean();
System.out.print("请输入你的性别：");
char gender = scanner.next().charAt(0);//先按照字符串接收，然后再取字符串的第一个字符（下标为0）
System.out.println("你的基本情况如下：");
System.out.println("网名：" + name + "\n年龄：" + age + "\n体重：" + weight +
"\n单身：" + isSingle + "\n性别：" + gender);
//④ 关闭资源
scanner.close();
五、switch语句
JAVA
switch(表达式)中表达式的值必须是下述几种类型之一：
byte，short，char，int，枚举 (jdk 5.0)，String (jdk 7.0)；
C语言
switch(表达式)中表达式的值必须是 整型 和 字符型，表达式可以是表达式 但必须是一个常量
共同点：case子句中的值必须是常量，不能是变量名或不确定的表达式值或范围；
switch(表达式){
case 常量值1:
语句块1;
//break;
case 常量值2:
语句块2;
//break;
// ...
[default:
语句块n+1;
break;
]
}
六、数组
JAVA
2. 数组(JAVA)
2.1静态初始化:如果数组变量的初始化和数组元素的赋值操作同时进行
一维数组声明和静态初始化格式1:
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3,...};
或
数据类型[] 数组名;
数组名 = new 数据类型[]{元素1,元素2,元素3,...};
注意：Java语言中声明数组时不能指定其长度(数组中元素的个数)。 例如： int a[5];
2.2动态初始化:数组变量的初始化和数组元素的赋值操作分开进行
数组存储的元素的数据类型[] 数组名字 = new 数组存储的元素的数据类型[长度];
或
数组存储的数据类型[] 数组名字;
数组名字 = new 数组存储的数据类型[长度];
2.3数组的长度：
JAVA：arr.length 指明数组arr的长度(即元素个数)
C；sizeof(arr)
2.4 二维数组 -->每行长度可能不一致
1 静态初始化:元素的数据类型[][] 二维数组的名称;
2 动态初始化：
格式1：规则二维表：每一行的列数是相同的
int[][] arr = new int[3][2];
格式2：不规则：每一行的列数不一样
//（1）先确定总行数
元素的数据类型[][] 二维数组名 = new 元素的数据类型[总行数][];
//此时只是确定了总行数，每一行里面现在是null
//（2）再确定每一行的列数，创建每一行的一维数组
二维数组名[行下标] = new 元素的数据类型[该行的总列数];
//此时已经new完的行的元素就有默认值了，没有new的行还是null
//(3)再为元素赋值
二维数组名[行下标][列下标] = 值;
3 遍历规则：
for(int i=0; i<二维数组名.length; i++){ //二维数组对象.length
for(int j=0; j<二维数组名[i].length; j++){//二维数组行对象.length
System.out.print(二维数组名[i][j]);
}
代码举例：
一维数组
//数组的定义
//静态定义
int[] arr = new int[]{1, 2, 3, 4, 5};//方法一
int[] arr1;
arr1 = new int[]{1, 2, 3, 4, 5};//方法二：用new创建数组实体
int[] arr2 = {1, 2, 3, 4, 5};//方法三 省略new int[] 默认为int
int arr3[] = {1, 2, 3, 4, 5};//方法四 类似c语言
/*错误情况：（重要tips）
一.
int[] arr4;
arr4={1, 2, 3, 4, 5};//不可以这样 注意与方法三的区别
二.
int[] arr5=new int[5]{1, 2, 3, 4, 5};//错误 不可以int[5] 相当于动态和静态一起使用了
*/
//动态定义:后续可以循环给每个元素赋值
int[] arr01=new int[5];//方法一
int[] arr02;//方法二
arr02=new int[5];
System.out.println("arr02的地址："+arr02);
System.out.println("arr02的长度："+arr02.length);
System.out.print("arr02的元素为：[");
for (int i = 0; i < arr02.length; i++) {
if (i==0){
System.out.print(i);
} else {
System.out.print(" ,"+i);
}
}
System.out.print("]");
System.out.println();
//默认值分析****（不同点）
int[] a1=new int[5];//默认0
System.out.println(a1[0]);
double[] a2=new double[5];//默认0.0
System.out.println(a2[0]);
boolean[] a3=new boolean[5];//默认false
System.out.println(a3[0]);
char[] a4=new char[5];//默认0 不是‘0’
System.out.println(a4[0]);
String [] a5=new String[5];//默认null
System.out.println(a5[0]);
// 定义数组，存储3个元素
int[] arr001 = new int[3];
//数组索引进行赋值
arr001[0] = 5;
arr001[1] = 6;
arr001[2] = 7;
//输出3个索引上的元素值
System.out.println(arr001[0]);//5
System.out.println(arr001[1]);//6
System.out.println(arr001[2]);//7
//定义数组变量arr2，将arr的地址赋值给arr2****（不同点）
int[] arr002 = arr001;
arr002[1] = 9;
System.out.println(arr002[0]);//5
System.out.println(arr002[1]);//9
System.out.println(arr002[2]);//7
二维数组 ： 最大区别是 每行长度可能不一致！
int[][] arr = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9, 10}};//声明与初始化必须在一句完成
System.out.println(arr[0].length);//3每列长度不一样 即列数不一致 ****（不同点）
System.out.println(arr[1].length);//3
System.out.println(arr[2].length);//4
int[][] arr1 = new int[][]{{1, 2, 3}, {4, 5, 6}, {7, 8, 9, 10}};
int[][] arr2;
arr2 = new int[][]{{1, 2, 3}, {4, 5, 6}, {7, 8, 9, 10}};
//错误示范 不可以写int[3][3] 和一维一样，只能是int[][]
//arr2 = new int[3][3]{{1, 2, 3}, {4, 5, 6}, {7, 8, 9, 10}};//错误，静态初始化右边new 数据类型[][]中不能写数字
*/
//举例说明：
//1、声明一个二维数组，并且确定行数
//因为每一行的列数不同，这里无法直接确定列数
int[][] arr = new int[5][];
//2、确定每一行的列数
for(int i=0; i<arr.length; i++){
/*
arr[0] 的列数是1
arr[1] 的列数是2
arr[2] 的列数是3
arr[3] 的列数是4
arr[4] 的列数是5
*/
arr[i] = new int[i+1];//有点类似一维数组了 *****（不同点）
}
//3、确定元素的值 遍历方法 *****（重要）
for(int i=0; i<arr.length; i++){
for(int j=0; j<arr[i].length; j++){
arr[i][j] = i+1;
}
}
//4、遍历显示
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();
}
C语言
数组(C)
//静态初始化
int arr[5]={1,2,3,4,5};//方法一：arr[5] 5写不写都得
int arr1[5];//方法二
int arr2[5]={1,2,3,4,5};
strcpy(arr1,arr2);//不arr1={1,2,3,4,5};
//动态定义数组
int *p=(int *)maloc(sizeof(int)*5);//动态定义数组 p指针指向一个大小为5的地址空间
//二维数组
int arr[][]={{1,2},{},{3,4,5}}//此处为arr[3][3] 行列都是三
int arr[2][2]={{1},{}}//此处为arr[2][2] 行列都是二
七、JAVA面向对象基础
这个是java独有的，语法上差异比较大，独立学习：
学习面向对象内容的三条主线
Java类及类的成员：（重点）属性、方法、构造器；（熟悉）代码块、内部类
面向对象的特征：封装、继承、多态、（抽象）
其他关键字的使用：this、super、package、import、static、final、interface、abstract等
JAVA
面向对象编程（基础）
(2024.4.19)
面向对象完成具体功能的操作的三步流程：
1.创建类，并设计类的内部成员（属性、方法）
2.创建类的对象
3.通过对象，调用类的属性和方法，完成相应的功能
(2024.4.20)
1. 对象名其实是一个引用数据类型 代表的是地址
2. 面向对象执行过程中变量存储位置分析:
栈：先存入一个main ()帧，变量，以及函数调用 局部变量
堆：对象实例（new出来的对象属性都是存放在这里）成员变量
方法区：同修饰符的方法能够不管先后顺序相互调用，不同修饰符的不可以相互调用
3. 随机数的获取：
1、Math类的random()的调用，会返回一个[0,1)范围的一个double型值
2、Math.random() * 100 ---> [0,100)
(int)(Math.random() * 100) ---> [0,99]
(int)(Math.random() * 100) + 5 ----> [5,104]
3、如何获取`[a,b]`范围内的随机整数呢？`(int)(Math.random() * (b - a + 1)) + a`
4. 方法重载：(c语言不允许)
方法重载：在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可。
注意：与修饰符、返回值类型无关，只与函数名有关，只看参数列表，且参数列表必须不同。(参数的个数，类型.顺序，不同）
//重载-->和修饰符无关
public void a(int i) {
}
public double a(double i) {
return i;
}
5. 可变形参：方法名(参数的类型名 ...参数名)
books其实是数组名，来存储多个参数,长度：args.length
public static void test(int a ,String[] books);
public static void test(int a ,String...books);
主函数其实传入的就是可变形参:public static void main(String[] args)
6. 交换两个元素的值
java没有指针的概念，不可以进行变量的地址传递,可以通过下面再这种方式来进行：（或者使用的是对象来传递）
public void swap(int[] arr,int i, int j){
int temp =a[i];
a[i]=a[j];
a[j]=temp;
}
7. 面向对象特征一：封装性(encapsulation)
面向对象的开发原则要遵循“ 高内聚、低耦合 ”
高内聚 ：类的内部数据操作细节自己完成，不允许外部干涉；
低耦合 ：仅暴露少量的方法给外部使用，尽量方便外部调用。
通俗的讲，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。
权限修饰符： public > protected > 缺省 > private
封装性的体现：
1.成员变量/属性私有化:私有化类的成员变量，提供公共的get和set方法，对外暴露获取和修改属性的功能。
2.私有化方法
注意：开发中，一般成员实例变量都习惯使用private修饰，再提供相应的public权限的get/set方法访问。
8. Java里方法的参数传递方式只有一种： 值传递。
即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。
形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参
形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参
9. 构造器：之前都是显性赋值或者方法赋值，可以用构造器进行赋值
1.无参构造：
// 无参构造
public Student() {}
2.有参构造：
// 有参构造
public Student(String n,int a) {
name = n;
age = a;
}
说明：
1. 构造器名必须与它所在的类名必须相同。
2. 它没有返回值，所以不需要返回值类型，也不需要void。
3. 构造器的修饰符只能是权限修饰符，不能被其他任何修饰。比如，不能被static、final、
synchronized、abstract、native修饰，不能有return语句返回值。
4.默认无参构造
5. 在类中，至少会存在一个构造器。
6. 构造器是可以重载的。
10. JavaBean：所谓JavaBean，是指符合如下标准的Java类：
类是公共的
有一个无参的公共的构造器
有私有属性，且有对应的get、set方法
八、JAVA面向对象进阶
JAVA
面向对象编程（进阶）(2024.4.26)
1.this:
1.可以用this来区分`成员变量`和`局部变量（主要常用功能）
public void setName(String name){
this.name = name;
}
2.this可以作为一个类中构造器相互调用的特殊格式。
- this()：调用本类的无参构造器
- this(实参列表)：调用本类的有参构造器
3.注意：
- 不能出现递归调用。比如，调用自身构造器。
- 推论：如果一个类中声明了n个构造器，则最多有 n - 1个构造器中使用了"this(形参列表)"
- this()和this(实参列表)只能声明在构造器首行。
- 推论：在类的一个构造器中，最多只能声明一个"this(参数列表)"
4.代码举例 :
// 无参构造
public B_Student() {
// this("",18);//调用本类有参构造器
System.out.println("无参 this()");
}
// 有参构造
public B_Student(String name) {
this();//调用本类无参构造器
this.name = name;
System.out.println("一个参数 this(name)");
}
// 有参构造
public B_Student(String name, int age) {
this(name);//调用本类中有一个String参数的构造器
this.age = age;
}
2.面向对象特征二：继承(Inheritance)
[修饰符] class 类A {
...
}
[修饰符] class 类B extends 类A {
...
}
1.类A，称为父类、超类、基类(base class)、SuperClass
类B，称为子类、派生类(derived class)、SubClass
2.子类会继承父类所有的实例变量和实例方法，并在此基础上进行扩展延伸
3.子类虽会继承父类私有(private)的成员变量，但子类不能对继承的私有成员变量直接进行访问，可通过继承的get/set方法进行访问
4.一个父类可以拥有多个子类
5.一个类只能有一个父类，不可以有多个直接父类。class C extends A,B... //error
3.方法的重写与重载的区别
1.子类可以对从父类中继承来的方法进行改造，我们称为方法的重写（一般情况下都是直接赋值父类的方法）
要求：1.子类重写的方法`必须`和父类被重写的方法具有相同的`方法名称`、`参数列表`。
2.类重写的方法的返回值类型`不能大于`父类被重写的方法的返回值类型
3.子类重写的方法使用的访问权限`不能小于`父类被重写的方法的访问权限。
4.子类方法抛出的异常不能大于父类被重写方法的异常
2.区别：方法的重载：方法名相同，形参列表不同。不看返回值类型。
4.this与super
1、this和super的意义
this：当前对象
- 在构造器和非静态代码块中，表示正在new的对象
- 在实例方法中，表示调用当前方法的对象
super：引用父类声明的成员
2、this和super的使用格式
- this.成员变量：表示当前对象的某个成员变量，而不是局部变量
- this.成员方法：表示当前对象的某个成员方法，完全可以省略this.
- this()或this(实参列表)：调用另一个构造器协助当前对象的实例化，只能在构造器首行，只会找本类的构造器，找不到就报错
- super
- super.成员变量：表示当前对象的某个成员变量，该成员变量在父类中声明的
- super.成员方法：表示当前对象的某个成员方法，该成员方法在父类中声明的
- super()或super(实参列表)：调用父类的构造器协助当前对象的实例化，只能在构造器首行，只会找直接父类的对应构造器，找不到就报错
3.注意：class B extends A{ }
A类和B类都是默认有一个无参构造，B类的默认无参构造中还会默认调用A类的默认无参构造
创建子类对象，若此时父类已经定义了有参构造但是没有定义无参构造，则会报错
如果在子类构造器的首行既没有显示调用"this(形参列表)"，也没有显式调用"super(形参列表)"，
则子类此构造器默认调用"super()"，即调用父类中空参的构造器。
5.面向对象特征三：多态性
1.对象的多态性：父类的引用指向子类的对象
父类类型 变量名 = 子类对象；-->Person p = new Student()
2.编译时，看左边；运行时，看右边。意思就是说还没运行时，系统会显示父类的数据类型，但是
实际调用方法时，结果是看子类的数据类型（继承）成员变量没有多态性
3.多态的使用前提：
1. 类的继承关系
2. 方法的重写
3. 适用于方法，不适用属性
4.编译时看父类：只能调用父类声明的方法，不能调用子类扩展的方法，真的要调用的话就要进行强制转换
5.向上转型与向下转型：如同数据类型转换一样进行转换，目的就是使用子类特有的方法
Pet pet = new Dog();
//pet.watchHouse();//不能调用父类没有的方法watchHouse
Dog d = (Dog) pet;
d.watchHouse();//可以调用子类扩展的方法watchHouse
6.由5引出instanceof：判断对象是哪种数据类型
if (e instanceof Graduate/Student/Person) {...} 之后进行下一步操作
6. Object 类的使用
1.类 `java.lang.Object`是类层次结构的根类，即所有其它类的父类。每个类都使用 `Object` 作为超类。
2.(重点)equals():A.equals(B)
1.==和equals的区别:== 既可以比较 基本类型 也可以比较 引用类型 。
对于基本类型就是比较值，对于引用类型就是比较内存地址
2.特例：当用equals()方法进行比较时，对类File、String、Date及包装类（Wrapper Class）来说，是比较类型及内容而不考虑引用的是否是同一个对象；
原因：在这些类中重写了Object类的equals()方法，要不然都是new出来的对象，为引用数据类型，其结果肯定为false
3.(重点)toString()：public String toString()
如果我们直接System.out.println(对象)，默认会自动调用这个对象的toString()
但是不进行重写的话，一般打印的是charpter03.B_Student@1b6d3586，进行重写之后，返回字符串的值
说明：重写之后，
System.out.println(student.toString());//.toString()写不写都行，
因为默认会自动调用这个对象的toString()，
九、JAVA面向对象高级
JAVA
面向对象编程（高级）(2024.4.26-28)
1.关键字：static
1.静态变量:使用static修饰的成员变量就是静态变量（或类变量、类属性）
如果权限修饰符允许，在其他类中可以通过“`类名.静态变量/方法`”直接访问，
也可以通过“`对象.静态变量/方法`”的方式访问（但是更推荐使用类名.静态变量的方式）。
2.静态方法:用static修饰的成员方法就是静态方法。
1.在static方法内部只能访问类的static修饰的属性或方法，不能访问类的非static的结构。
2.静态方法可以被子类继承，但不能被子类重写
3.static方法内部不能有this，也不能有super
3.相同点：
1. 如果权限修饰符允许，在其他类中可以通过“`类名.静态变量/方法`”直接访问，
也可以通过“`对象.静态变量/方法`”的方式访问（但是更推荐使用类名.静态变量的方式）。
2.在本类的任意方法、代码块、构造器中都可以直接被调用
3. 能否直接调用（类/对象.对象/方法（static））
静态变量 实例变量
类 1 0
对象 1 1
2.单例模式的两种实现方式
概念：采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。
1.饿汉式：没有多线程安全问题，在使用类的时候已经将对象创建完毕，耗费内存
class Singleton {
// 1.私有化构造器
private Singleton() {
}
// 2.内部提供一个当前类的实例
// 4.此实例也必须静态化
private static Singleton single = new Singleton();
// 3.提供公共的静态的方法，返回当前类的对象
public static Singleton getInstance() {
return single;
}
}
2.懒汉式：调用静态方法时实例才被创建，节约内存，线程不安全
class Singleton {
// 1.私有化构造器
private Singleton() {
}
// 2.内部提供一个当前类的实例
// 4.此实例也必须静态化
private static Singleton single;
// 3.提供公共的静态的方法，返回当前类的对象
public static Singleton getInstance() {
if(single == null) {
single = new Singleton();
}
return single;
}
}
3.代码块
1.静态代码块：
不可以调用非静态的属性和方法，若有多个静态的代码块，
那么按照从上到下的顺序依次执行
静态代码块的执行要先于非静态代码块
静态代码块随着类的加载而加载，且只执行一次
2.非静态代码块
每次创建对象的时候，都会执行一次。且先于构造器执行
3.实例变量赋值顺序
默认->显示赋值/代码块->构造器->对象.属性/对象.方法
注意：显示赋值/代码块先后表示的是运行的先后顺序
4.final关键字
1.可以修饰类、方法、变量，一旦修饰就不可以更改
类：表示这个类不能被继承，没有子类
方法：不能被子类重写
变量：值就不能被修改，即常量，常量名建议使用大写字母。
2.类似c语言的const
5.抽象类与抽象方法(或abstract关键字)---->不能创建对象,子类重写全部方法
1.没有具体的实例，这样的类叫做抽象类
2.使用说明：
1.抽象类不能创建对象，抽象类的子类必须重写父类的抽象方法，并提供方法体。若没有重写全部的抽象方法，仍为抽象类。
2.抽象类中，也有构造方法
3.抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类
4.抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。
3.注意事项
- 不能用abstract修饰变量、代码块、构造器；
- 不能用abstract修饰私有方法、静态方法、final的方法、final的类。
6.接口(interface)
1.继承是一个"是不是"的is-a关系，而接口实现则是 "能不能"的`has-a`关系
2.接口的使用规则：
1.接口不能创建对象，但是可以被类实现（`implements` ，类似于被继承）
2.如果接口的实现类是非抽象类，那么必须`重写接口中所有抽象方法`。
3.默认方法可以选择保留，也可以重写
4.接口中的静态方法不能被继承也不能被重写
5.一个类能继承一个父类，同时实现多个接口。
6.一个接口能继承另一个或者多个接口
3.接口最重要的特性是利用多态！！！
4.接口不能直接创建对象，但是可以通过接口名直接调用接口的静态方法和静态常量
7.枚举类
具体设计模板见H，比较通用
8. 包装类
1.会用一些常用得基本数据类型与包及String得转换即可
基本-->包装类；
1.Integer integer = new Integer(a);//a为int数据
2.Integer integer = new Integer("7");//String数据
3.Integer integer = Integer.valueOf(45);//使用的是包装类.valueOf(x)的方法，自动类型转换底层也就是这个
4.Integer integer2=12;integer2++;//自动类型转换
包装类-->基本；
int i=integer.intValue();//拆箱
String-->基本、包装类
1.String s1="123";int i4=Integer.parseInt(s1);//类型得一致
基本、包装类-->String
1.int a=54;String str1=String.valueOf(a);//也是使用包装类.valueOf(x)的方法
2.或者直接String str3=a+"";拼接
2.掌握自动装箱拆箱，见MyInteger
- 包装类常见转换：记得自动转换以及与String的转换。
1623
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
