第九节初识数组

一， 回顾

面向对象 – 是一种编程思想 – 一切事物皆对象

1， 两大核心：

类 ： 对同一类事物的抽象描述（属性： 成员变量， 功能： 成员方法）

对象： 对象是类的具体事例， 对象中有属性和功能

2， 如何创建一个对象

类名 对象名 = new 构造方法（）；

3， 构造函数 – 构造方法– 构造器

功能作用： 创建一个对象， 并且初始化对象的属性值

声明：

修饰符： 访问权限

返回值： 没有返回值， 并且也不能写void

方法名： 必须和类完全一致

调用： new 关键字来调用， 表示创建一个对象， 开辟一块内存

4， 方法的重载

必须在同一个类中

方法名相同

参数列表不同（顺序， 个数， 参数类型）

5， this 关键字

5.1 指代本类的对象， 可以访问成员变量和方法

可以区分同名的成员变量和局部变量

this.name

5.2 指代构造函数， this() – 必须写在首行位置

this(“张三”,21)；

6, 参数的传递

形参 ： 声明方法的时候参数列表

实参 ： 在调用方法的时候， 传入的实际的参数内容

基本数据类型

传递的是数据的本身， 其实将数值拷贝一份， 赋值给形参；

引用数据类型

传递的是对象的引用（对象的地址）， 由两个引用，指向同一个对象

7， 封装

出于安全的考虑

类中的属性， 可以被任意对象访问， 所有会造成数据的不安全， 所有需要封装

操作的步骤：

1， 在声明属性的时候 ， 加入private ， 就意味着该属性只能在本类中使用

2， 通过setXXX 和 getXXX 方法， 进行赋值和取值

8， static

关键字 – 修饰符， 表示的是静态的， 属性类所有

随着类的加载而加载 – > 在对象之前就已经加载

属性： 成员变量

属于类所有， 并且只有一份

静态的属性随着类的加载而加载 ； 非静态的属性， 随着对象的创建而产生的

功能： 成员方法

静态的方法由类来调用， 非静态的方法是由对象来调用；

静态的方法中， 不能访问非静态的成员变量和成员方法，但是可以访问静态的

非静态的方法中， 可以访问非静态的和 静态的成员变量和成员方法

class Demo01

{

String name = “张三”；//全局变量 – 成员变量 – 类中随处可用

static int age;

public static void add(int a,int b){

int result = 0;//局部变量 – 只能在本代码块中使用

}

public void sum(int a,int b){}

public static void main(String[] args)

{

//静态方法的调用 – 类所有

//Demo01.add(1,2); 在其他类中调用

add(1,2);//本类中调用

//非静态方法的调用 – 对象所有

Demo01 demo = new Demo01();

demo.sum(1,2);}

}

class Demo02

{

public static void main(String[] args) {

Demo01.age;// 获取静态的变量

Demo01.add(3,5);

Demo01 demo = new Demo01();

demo.sum(3,4);

}

}

代码块：

普通代码块： 就是一块代码 - 方法中： { 普通代码块 }

构造代码块： 类中， 方法外， 随着构造函数的执行而执行， 优先于构造函数来执行

静态代码块： static 关键字来修饰的， 只执行一次， 并且优先于main方法执行

同步代码块： 线程中

内部类：

9， 聚合关系

一个类作为另一个类的属性

10， 继承 – 面向对象的特征之一

描述的是两个类之间的关系 – 一个类作为子类， 一个类作为父类

作用： 意义和目的

1， 避免重复的代码

2， 增强了程序的扩展性

两个类存在继承关系：

1， 子类可以访问父类中非私有的属性和方法， 但是父类不能访问子类新增的方法和属性

2， 子类可以新增直接的属性和方法 – 扩展性

3， 子类可以重写父类的方法

一个类只能有一个父类， – java 的单继承

11， 重写

1， 存在于继承关系中

2， 子类中方法的声明和父类中方法一致（返回值类型，方法名， 参数列表）

3， 子类的访问权限不能比父类的更加严格

4， 子类重写的方法， 不能抛出比父类更大的异常

12， 访问权限：

public ： 公共的， 都可以访问， 没有限制

protected ：受保护的， 本类， 本包， 不同包中限于其子类使用

default ： 默认的， 本类， 本包

private ： 私有的， 本类

13， 子类对象的创建

任何一个子类对象的创建， 都是先调用父
b9b5
类的构造函数， 默认调用无参的构造函数，然后才会执行子类的构造函数

14， super

1， 指代父类的构造函数 – super() 必须在第一行显示 – 所有不能和this() 一起使用

2， 访问父类的属性和方法

super.父类的属性

super.父类的方法

class Fu

{

String name;

public Fu()

{

}

public Fu(int a,int b)

{

}

public Fu(int a,int b,int c)

{

}

}

class Sub extends Fu

{

public Sub(){

//super();

super(1,2,3);

super.name = “张三”;

15， final 关键字 – 最终的

属性 ： 被final 修饰的属性称之为常量， 只能赋值一次

类： 被final 修饰的类， 不能被继承

方法： 被final 修饰的方法，不能被重写

16， Object 类 – 所有类的父类， extends Object 可写，可不写

toString()

不重写： 输出的是对象的地址

重写了： 输出的是对象的属性值

equals() – 比较内存中的地址是否一致

特殊的： String – 底层代码中， 重写了父类Object 的 equals() 方法；

判断两个属性的内容是否相等

如果你自定义的类， 想判断内容是否相等， 则重写equals() 就可以了

17, 抽象类： – 不可以实例化 – 存在于继承关系中

抽象方法： 当父类要求子类必须要重写的方法， 声明为抽象的；

如果类中存在抽象的方法， 则该类必须是抽象类

抽象类的特点：

1， 没有方法体的方法是抽象的方法， 而抽象的方法一定定义在抽象类中

2， 抽象类和抽象的方法被 abstract 关键字来修饰， abstract只能修饰类和方法

3， 抽象类不能被实例化， 也就意味着不能创建对象

4， 子类必须要重写抽象类中的所有的抽象方法

抽象类和普通类的区别：

相同点：

都是可以用来描述事物的， 都可以定义属性和方法， 和构造方法

不同点：

普通类中不可以定义抽象的方法，而抽象类可以

普通类可以被实例化， 而抽象类不可以

普通类中的方法可以被重写也可以不重写， 而抽象类中的抽象方法必须要被重写

抽象类不能与 static ， final ， private 关键字一起使用

18， 接口 – 比抽象类还要抽象的 – 接口中都是抽象的方法

接口可以多实现

声明接口：

interface 接口名

{

接口的内容

}

实现接口的关键字： implements

19， 多态 – 一个对象， 多种形态

子类是一个特殊的父类；

子类的对象， 即可以作为父类的对象， 由父类来引用；

又可以作为子类的对象， 由子类来引用。

Animal animal = new Dog();// 狗是动物 – 向上类型转换

Dog dog = (Dog)animal;//动物是狗 – 向下类型转换

instanceof 关键字， 判断一个对象， 是否属于一个类

if(Animal instanceof Dog){ //如果不加该判断， 则会抛出异常， 类型转换异常

//如果符合要求则， 转换

Dog dog = (Dog)animal;

}

20， 内部类

实例内部类

相当于一个类中的实例属性和非静态的方法（非静态的属性）， 属于外部类对象所有，

所有需要由外部类的对象来创建内部类的对象

Outer outer = new Outer();

Outer.Inner inner = outer.new Inner();

静态内部类

相当于外部类的静态属性和静态的方法， 属于外部类所有， 需要通过外部类直接调用

Outer.Inner inner = new Outer.I1, 可以访问外部类中的静态属性和方法

2， 不能访问外部类中的非静态的属性和方法， 必须要先创建外部类的对象才可以

局部内部类

外部类的方法中

访问外部类中的静态和非静态的属性和方法， 可以访问外部类的私有属性

匿名内部类

没有名字的类 – 以抽象类和接口为前提

通过new 关键字， 创建该实现类的对象

new JieKou(){

@Override

public void test()

{

}

};

二， 今天的内容 – 数组

数组 – 是java 容器中的一种

基本数据类型的数组

引用数据类型的内存图

1： 定义

一个变量只能存一个数据， 如果想要存储多个数据， 就需要通过数组来完成

同一个类型的数据集合， 数组其实就是一个容器

2， 数组的特点：

要求必须存储同一种类型的数据

存储时必须要明确元素的个数

3， 数组其实就是存储了固定个数并且必须是同一类型的元素的容器

4， 分类

一维数组

二维数组

5， 一维数组 声明的格式

格式一：

元素类型[] 数组名 = new 元素类型[元素的个数 或者 数组的长度];

格式二：

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

简化版

元素类型[] 数组名 = {元素1， 元素2， 元素3…}；

6， 数组中常见的异常

java.lang.ArrayIndexOutOfBoundsException – 数组下标越界异常

语法没有错误 编译时没错 运行错误

当访问的数组中不存在该角标,就会抛出数组下标越界异常

java.lang.NullPointerException – 空指针异常

出现的原因:当引用数据类型的变量没有具体指向的实体时,然后变量还要操作其具体的实例,就会抛出空指针异常

7， 迭代

1， for循环迭代数据

2， 增强for 循环

for(循环变量的类型 循环变量的名称 ：要遍历的对象)

{

循环体内容；

}

要遍历的对象： 可以使数组也可以是集合

循环变量类型: 其实就是数组的 数据类型

循环变量的名称：可以自定义， 迭代显示的内容 – 数组中存放的每个数据

好处： 针对的都是容器， 遍历的过程交由编译器去执行，增强for循环比普通的for 速度快

弊端： 在遍历的过程中，不能输出数组的角标

8， 求最大值：

定义一个变量， 存目前最大的值

for 循环遍历， 遇到较大的值， 更改当前记录的最大值

循环结束后， 就能得到最大的值

9， 排序

选择排序

冒泡排序

10， 顺序查找 — 找角标

11， 角标 – 下标， 编号 – 从0开始