一：
讲解String和
StringBuffer两个类
二：
2.1
二维数组：其实二维数组其实就是一个元素为一维数组的数组。
动态初始化方式一（指定有多少个长度相同的一维数组）：
数据类型[][] 变量名 = new 数据类型[m][n];
m表示这个二维数组有多少个一维数组
n表示每一个一维数组的元素个数
需求：请定义一个二维数组,二维数组有三个一维数组,每个一维数组有两个元素。
1.打印二维数组名称
2.打印每一个一维数组
3.不给元素赋值打印元素
4.赋值后打印元素
画出内存图解
2.2
动态初始化方式二（指定二维数组中有多少个一维数组，每一个一维数组的长度不固定）：
数据类型[][] 变量名 = new 数据类型[m][];
注意：
m这个数据必须给出，后面的数据可以不给
需求：定义一个有3个一维数组的二维数组
1.给这个二维数组的每一个一维数组的元素赋值
仅可用此种方式：
arr[0] = new int[2];
arr[0][0] = 1;
arr[0][1] = 2;
不能用此种方式：
/*
arr[0] = {1,2};
arr[1] = {5,6,7};
arr[2] = {4};
*/
2.打印二维数组的名称
3.打印二维数组中每一个一维数组的名称
4.打印二维数组中的每一个一位数组中的元素（手动打印几个即可）
画出内存图解
2.3
二维数组的静态初始化：
静态初始化：
数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
简化格式：
数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
需求：定义一个里面有3个长度一样的一维数组的二维数组（使用静态初始化）
需求：定义一个里面有3个长度不一样的一维数组的二维数组（使用静态初始化）
2.4 二维数组的遍历：
需求：定义一个里面有3个长度不一样的一维数组的二维数组，并遍历
2.5 二维数组的求和：
公司年销售额求和
某公司按照季度和月份统计的数据如下：单位(万元)
第一季度：22,66,44
第二季度：77,33,88
第三季度：25,45,65
第四季度：11,66,99
三：形式参数问题
看程序写结果（画内存图进行分析）
class ArgsDemo {
public static void main(String[] args){
int a = 10;
int b = 20;
System.out.println("a:"+a+",b:"+b); //10,20
change(a,b);
System.out.println("a:"+a+",b:"+b); //?
int[] arr = {1,2,3,4,5};
change(arr);
System.out.println(arr[1]); //4
}
public static void change(int a,int b) {
System.out.println("a:"+a+",b:"+b); //10,20
a = b;
b = a + b;
System.out.println("a:"+a+",b:"+b);/20,40
}
public static void change(int[] arr) {
for(int x=0; x<arr.length; x++) {
//如果数组的元素值是偶数，就变为以前的2倍。
if(arr[x]%2==0) {
arr[x]*=2;
}
}
}
}
结论：
如果形式参数是基本类型：
形式参数的改变，不影响实际参数。
如果形式参数是引用类型：
形式参数的该变，直接影响实际参数。
四 .数组的高级操作（冒泡排序，选择排序，数组工具类，练习）
一：冒泡排序
1.1 看视频得出结论：
1.2 冒泡排序基本概念是：
相邻的两个元素进行比较，小的放前面，大的放后面
1.3 画图讲解冒泡排序，int[] arr = { 24, 69, 80, 57, 13 };
1.4 文字分析比较过程
第一次比较：比较了4次，最大的值放到了最后
第二次比较：比较了3次，次大的值放到了倒数第二
。。。依次类推
二：选择排序：
2.1 选择排序概念：
* 选择排序：
* 从0索引开始，依次和后面的每一个元素进行比较
* 第一次比较完毕，最小值出现在了最小索引处
* 第二次比较完毕，次小值出现在了次小索引处
* ...
* 完毕后，就排序了。
2.2 画图讲解选择排序规则
2.3 运用选择排序int[] arr = { 24, 69, 80, 57, 13 };进行排序
三：Arrays数组工具类
3.1 针对数组进行操作的工具类。提供了排序，转换等功能。
3.2
* 成员方法：
* public static String toString(int[] a):把数组转成字符串
* public static void sort(int[] a):对数组进行排序（有重载）
四：练习（运用冒泡排序和数组工具类两种方式实现）
* 把字符串中的字符进行排序。
* 举例：”dacgebf”
* 结果：”abcdefg”
五：作业
1.键盘录入一个字符串，判断是否是对称的，并且给出提示（2种方式实现）
2.从键盘输入10个数字,用冒泡排序进行从小到大的排序
3：把abcdefg反转成gfedcba
4：有abasdcalsjdfasf34asfjsfasf一段字符串，找出其中重复最多的字符，和重复最少的字符和重复的次数！
一：继承
1.1
如何表达这个关系呢?
通过extends关键字可以实现类与类的继承
格式：
class 子类名 extends 父类名 {
}
父类：基类，超类
子类：派生类
需求：
学生类：
成员变量：name,age
构造方法：无参,带参
成员方法：getXxx()/setXxx(),eat(),sleep()
老师类：
成员变量：name,age
构造方法：无参,带参
成员方法：getXxx()/setXxx(),eat(),sleep()
非继承版代码
1.2
需求：（需要加入方法重写）
学生类：
成员变量：name,age
构造方法：无参,带参
成员方法：getXxx()/setXxx(),eat(),sleep()
老师类：
成员变量：name,age
构造方法：无参,带参
成员方法：getXxx()/setXxx(),eat(),sleep()
按照我们刚才对继承的概述，我们可以找一个父类。
人类：
成员变量：name,age
构造方法：无参,带参
成员方法：getXxx()/setXxx(),eat(),sleep()
学生类：继承人类就可以了。
老师类：继承人类就可以了。
继承的好处：
A:提高了代码的复用性
多个类相同的成员可以放到同一个类中
B:提高了代码的维护性
如果功能的代码需要修改，修改一处即可
C:让类与类之间产生了关系，是多态的前提
方法重写(子类的方法名，参数和父类完全一样，将父类方法覆盖)：
1.必须存在继承关系
2.父类的方法满足不了你的需求，此时你就需要重写父类的方法，实现自己想要实现的功能
1.3
继承的特点：（代码演示）
A:Java只支持单继承，不支持多继承。
B:Java支持多层(重)继承(继承体系)。
什么时候使用继承呢?
继承中类之间体现的是：”is a”的关系。
采用假设法。
举例：水果，香蕉
举例：水杯，水果 (不能采用继承。)
举例：动物，狗
1.4
类的组成：
成员变量
构造方法
成员方法
继承间的成员变量关系：
A:名字不同，非常简单。
B:名字相同
首先在子类局部范围找
然后在子类成员范围找
最后在父类成员范围找(肯定不能访问到父类局部范围)
如果还是没有就报错。(不考虑父亲的父亲…)
就近原则。
需求：
请在show方法中输出40，30，20，10
class Fu {
public int num = 10;
}
class Zi extends Fu {
public int num2 = 20;
public int num = 30;
public void show() {
int num = 40;
请问这里面代码怎么写？？？
}
}
class ExtendsDemo5 {
public static void main(String[] args) {
Zi z = new Zi();
z.show();
}
}
怎么去访问父亲的成员呢?
java就提供了一个关键字：super
super:
super代表父类存储空间的标识(可以理解为父类对象)
this和super的使用区别?
A:成员变量
this.成员变量 本类的成员变量
super.成员变量 父类的成员变量
B:成员方法
this.成员方法() 本类的成员方法
super.成员方法()父类的成员方法
1.5
继承间的成员方法关系：
A:方法名不同，非常简单
B:方法名相同
首先在子类中找
然后在父类中找
如果还是没有就报错。(不考虑父亲的父亲…)
1.7
继承间构造方法的关系：
子类中所有的构造方法默认都会访问父类中空参数的构造方法(super())
为什么呢?
因为子类会继承父类中的数据，可能还会使用父类的数据。
所以，子类初始化之前，一定要先完成父类数据的初始化。
每个子类的构造方法的第一行，有一条默认的语句:
super();
注意：仅仅是完成数据的初始化，创建对象目前必须用new申请空间。
假如父类没有无参构造方法,该怎么办呢?
A:调用父类的其他构造方法。带参构造。
怎么访问呢?
super(...)
注意：
super(…)或者this(….)必须出现在第一条语句上。
因为如果可以放后面的话，就会对父类的数据进程多次初始化。所以，只能放在第一条语句上。
建议：
永远给出无参构造方法。
1.6
猫狗案例继承版
猫：
成员变量：type,name,age
构造方法：无参,带参
成员方法：getXxx()/setXxx()
show()
狗：
成员变量：type,name,age
构造方法：无参,带参
成员方法：getXxx()/setXxx()
show()
提取出动物类，完成代码，并测试。
DongWu -- Animal
gou -- Dog
mao -- Cat
1.7 水果案例继承版
苹果：
成员变量：品种，颜色，价格
构造方法：有参无参
成员方法：getXxx()/setXxx();
show()
橘子：
成员变量：品种，颜色，价格
构造方法：有参无参
成员方法：getXxx()/setXxx();
show()
提取水果类，完成代码，并测试
二：final关键字
在实际开发的时候，有些方法的内容一旦写定后，就不允许被改动。
即时是子类，也不允许。那么该怎么解决这个问题呢?
java为了解决这样的问题就提供了一个关键字：final
final:
最终的意思。它可以修饰类,方法,变量。
特点：
修饰方法，方法不能被重写。
修饰类，类不能被继承。
修饰变量，变量的值不能再改动。其实这个时候变量已经变成了常量。
常量：
A:字面值常量
'a',12,"hello"
B:自定义常量
就是把变量用final修饰。
定义一个常量。
final 数据类型 变量名;
三：多态
3.1
多态：同一个对象,在不同时刻表现出来的不同状态。
举例：
A:猫
猫是猫
猫是动物
B:水
水(液态)
冰(固态)
水蒸气(气态)
多态的前提：
A:有继承关系
B:有方法重写（不是必要条件，但是只有有了方法重写多态才有意义）
C:有父类引用指向子类对象
Fu f = new Fu();
左边：Fu类型的引用
右边：Fu类型的对象
Zi z = new Zi();
Fu f = new Zi();
3.2
成员访问特点
A:成员变量
编译看左边,运行看左边
B:构造方法
子类构造默认访问父类的无参构造
C:成员方法（重点理解）
编译看左边,运行看右边
为什么变量和方法不一样呢?
方法重写。
D:静态成员方法
编译看左边,运行看左边
因为静态的内容是和类相关的，与对象无关。
练习：
看程序写结果（先判断有没有问题，如果没有，写出结果）
class Fu {
public void show() {
System.out.println("fu show");
}
}
class Zi extends Fu {
public void show() {
System.out.println("zi show");
}
public void method() {
System.out.println("zi method");
}
}
class DuoTaiTest {
public static void main(String[] args) {
Fu f = new Zi();
f.method();
f.show();
}
}
练习：（猫狗案例演示）
如何使用子类特有功能
A:创建子类对象
B:把父类引用转为子类对象
向上转型
从子到父
父类引用指向子类对象
向下转型
从父到子
父类引用转为子类对象
四：抽象类
4.1
抽象类特点:
A:抽象类和抽象方法必须用abstract关键字修饰
B:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
C:抽象类不能实例化
那么，如果实例化并使用呢?
按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
D:抽象类的子类
要么是抽象类
要么重写抽象类中的所有抽象方法
抽象类的作用：
强制要求子类必须要重写某些方法。
4.2
抽象类 -- 特点 -- 成员特点 -- 案例
类的组成：
成员变量：
构造方法：
成员方法：
抽象类的成员：
成员变量：可以是变量，也可以是常量。
构造方法：有构造方法
不能实例化,构造方法有什么用呢?
用于子类访问父类数据的初始化。
成员方法：既可以是抽象的，也可以是非抽象的。
4.3 抽象类练习
以后我们在写代码的时候，有这样的分析过程。
分析：
从具体到抽象。
实现：
从抽象到具体。
使用：
使用具体的类。
猫：
成员变量：
name,age,type
构造方法：
有参无参
成员方法；
getXxx()/setXxx()
eat(),catchMouse()
狗：
成员变量：
name,age,type
构造方法：
有参无参
成员方法；
getXxx()/setXxx()
eat(),lookDoor()
发现有共性的内容，所以我们就提取出一个父类出来：
动物：抽象类
成员变量：
name,age,type
构造方法：
有参无参
成员方法；
getXxx()/setXxx()
eat()---抽象的
猫：
继承自动物
构造方法：
狗：
继承自动物
构造方法：
多态：
具体类多态
class Fu {}
class Zi extends Fu {}
抽象类多态
abstract class Fu {}
class Zi extends Fu {}
接口多态
多态的前提：
继承
方法重写
因为抽象类中的方法是抽象方法。
父类引用指向子类对象
作业分析（上课做简单分析，下课代码自己实现）：
老师案例
具体事物：基础班老师，就业班老师
共性：姓名，年龄，讲课。
自己分析自己写。
基础班老师：
成员变量：姓名，年龄
构造方法：无参，带参
成员方法：getXxx()/setXxx()
show()
讲课()
就业班老师：
成员变量：姓名，年龄
构造方法：无参，带参
成员方法：getXxx()/setXxx()
show()
讲课()
老师：抽象类
成员变量：姓名，年龄
构造方法：无参，带参
成员方法：getXxx()/setXxx()
show()
讲课() 抽象方法
基础班老师：
构造方法：无参，带参
成员方法：讲课() 抽象方法
就业班老师：
构造方法：无参，带参
成员方法：讲课() 抽象方法
五：接口
5.1 认识接口：不是我们现实生活中的usb接口等等实物的接口，类实现接口代表着这个类自身功能的一种扩展，
所以接口代表着一种扩展的能力
5.2
接口的特点：
A:定义接口要用关键字interface表示
格式：interface 接口名 {}
B:类实现接口用implements表示
格式：class 类名 implements 接口名 {}
C:接口不能实例化
那么，接口如何实例化呢?
按照多态的方式，由具体的子类实例化。其实这也是多态的一种，接口多态。
D:接口的实现类
要么是抽象类
要么重写接口中的所有抽象方法
多态的前提：
A:有继承或者实现关系
B:有方法重写
C:有父类引用或者父接口引用指向子类或者实现类对象
多态分类：
A:具体类多态
B:抽象类多态
C:接口多态
5.3
接口的成员特点：
A:成员变量
只能是常量。
默认修饰符：public static final
B:构造方法
没有构造方法
C:成员方法
只能是抽象方法。
默认修饰符：public abstract
5.4
类与类：
继承关系。只能单继承，可以多层(重)继承。
类与接口：
实现关系。可以单实现，也可以多实现。
还可以在继承一个类的同时实现多个接口。
接口与接口：
继承关系。可以单继承，也可以多继承。
5.5
接口和抽象类的关系最后分析：
抽象类和接口的区别
A:成员区别
抽象类：
成员变量：可以是变量，也可以是常量
构造方法：有构造方法
成员方法：可以是抽象方法，也可以是非抽象方法
接口：
成员变量：只能是常量。默认修饰符 public static final
成员方法：只能是抽象方法。默认修饰符 public abstract
B:关系区别
类与类：
继承关系。只能单继承，可以多层(重)继承。
类与接口：
实现关系。可以单实现，也可以多实现。
还可以在继承一个类的同时实现多个接口。
接口与接口：
继承关系。可以单继承，也可以多继承。
C:设计理念区别
抽象类被继承体现的是："is a"的关系。抽象类定义的是共×××。
接口被实现体现的是："like a"的关系。接口定义的是扩展功能。
5.6
继承，抽象类，接口代码综合演练
分析：从具体到抽象
实现：从抽象到具体
使用：使用具体类
猫狗案例,加入跳高的额外功能
猫：
成员变量：
name,age
构造方法：
无参,带参
成员方法：
getXxx()/setXxx()
show()
catchMouse()
eat()
跳高猫：继承自猫
成员方法：
跳高
狗：
成员变量：
name,age
构造方法：
无参,带参
成员方法：
getXxx()/setXxx()
show()
lookDoor()
eat()
跳高狗：继承自狗
成员方法：
跳高
无论猫还是狗，都是动物，所以我们提取出一个动物类：
跳高接口：
跳高
动物类：抽象类
成员变量：
name,age
构造方法：
无参,带参
成员方法：
getXxx()/setXxx()
show(){}
eat(); 抽象方法
猫：继承自动物
构造方法：
无参,带参
成员方法：
catchMouse()
eat()
跳高猫：继承自猫，实现跳高接口
构造方法：
无参,带参
成员方法：
跳高
狗：继承自动物
构造方法：
无参,带参
成员方法：
lookDoor()
eat()
跳高狗：继承自狗，实现跳高接口
构造方法：
无参,带参
成员方法：
跳高
5.7
给老师和学生加入抽烟的额外功能？？请用代码实现
分析：
老师 ：
成员变量：
构造方法：
成员方法：
学生：
成员变量：
构造方法：
成员方法：
抽取成人类：
提供抽烟接口：
