首页 > 代码库 > 五、六天笔记总结

五、六天笔记总结

一:

讲解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

给老师和学生加入抽烟的额外功能??请用代码实现


分析:

老师 :

成员变量:

构造方法:

成员方法:

学生:

成员变量:

构造方法:

成员方法:

抽取成人类:



提供抽烟接口:









五、六天笔记总结