Hello World_Java知识回顾（5）面向对象

最新推荐文章于 2022-10-02 21:33:14 发布

小东爱编程

最新推荐文章于 2022-10-02 21:33:14 发布

阅读量253

点赞数

分类专栏： Java知识回顾最新文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/weixin_46865682/article/details/123110608

版权

Java知识回顾最新专栏收录该内容

5 篇文章 0 订阅

订阅专栏

本文探讨了面向对象编程的基础概念，如面向对象思想的三大特征、类与对象的关系、构造方法与多态，以及异常处理的原理和实践。深入剖析了类的封装性、继承性和多态性，并介绍了如何创建对象和内存分析。还涉及了构造方法的重载和单例设计模式的应用。

摘要由CSDN通过智能技术生成

第一章面向对象基础

1.1 面向对象思想

1.1.1 概述

面向对象(Object Oriented)是软件开发方法。面向对象的概念和应用已超越了程序设计和软件开发，是一种对现实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。

面向对象是相对于面向过程来讲的，指的是把相关的数据和方法组织为一个整体来看待，从更高的层次来进行系统建模，更贴近事物的自然运行模式。

面向过程到面向对象思想层面的转变：

面向过程关注的是执行的过程，面向对象关注的是具备功能的对象。面向过程到面向对象，是程序员思想上从执行者到指挥者的转变。此概念如果直接去理解的话可能会比较抽象，因为大家缺少对原始的面向过程的开发语言的了解。

例子：

①我们通过生活中的一个脑筋急转弯，来理解这个概念。

问：

把大象装进冰箱，需要分几步？

回答：

面向过程回答： 3步：1把冰箱门打开， 2把大象装进去， 3把冰箱门关闭

面向对象回答： 2步：1招一个能操作冰箱的工人（对象），2指挥工人装大象

思考：

如果问题改成：把100只大象依次关进冰箱，共分为几步？

面向过程的回答：此处需要省略N字。。。

面向对象的回答还是2步： 1招一个能操作冰箱的工人（对象）， 2指挥工人把大象依次装进去。

结论：从上述的例子中，我们发现面向过程很死板，是很难适应变化的。而面向对象更灵活，可复用性更高。

②我们再描述一个生活的场景：场景：当我们独自生活时，我们经常纠结一日三餐怎么吃。

面向过程：每天亲力亲为：买菜 - 做饭 - 吃饭 - 洗碗的过程。

面向对象：招聘一个保姆，每天等吃即可。

场景升级：假设你是一个富豪，拥有一座占地3000亩地的庄园，不再是只关注吃饭问题，还有花草树木修剪，泳池维护清洗，卫生打扫，洗衣做饭。。。。。。

面向过程：此处省略看着就累的N字。

面向对象：招聘一个管家，然后让管家招聘园丁、泳池维护工、保姆等等。

结论：从上述的例子中，过程我们发现面向过程，我们需要关注很繁琐的。而面向对象不用关注具体的细节，更关注的是统筹架构的问题。其实我们进行大型应用开发时，就如上述的例子一样，如果我们写程序只关注过程的话，代码量达到一定层次以后，就很难再编写下去了。如果采用面向对象的思想来设计编写程序，会更有规范。

1.1.2 三大思想

面向对象思想从概念上讲分为以下三种：OOA、OOD、OOP

OOA：面向对象分析（Object Oriented Analysis）

OOD：面向对象设计（Object Oriented Design）

OOP：面向对象程序（Object Oriented Programming

1.1.3 三大特征

封装性：所有的内容对外部不可见

继承性：将其他的功能继承下来继续发展

多态性：方法的重载本身就是一个多态性的体现

1.2：类与对象

1.2.1 两者关系

类表示一个共性的产物，是一个综合的特征，而对象，是一个个性的产物，是一个个体的特征。（类似生活中的图纸与实物的概念。）

类必须通过对象才可以使用，对象的所有操作都在类中定义。

类由属性和方法组成： ·

属性：就相当于人的一个个的特征

· 方法：就相当于人的一个个的行为，例如：说话、吃饭、唱歌、睡觉

1.2.2、类的定义格式

class 类名称{

     成员属性

     成员方法

}

1.2.3、属性与方法

属性定义格式：

数据类型属性名;

属性定义并赋值的格式：

数据类型属性名 = 初始化值;

方法定义格式：

权限修饰符返回值类型方法名(形式参数列表){

//方法体

return 返回值；

}

1.2.4、对象的创建与使用

一个类要想真正的进行操作，则必须依靠对象，对象的定义格式如下:

类名称对象名称 = new 类名称() ;

如果要想访问类中的属性或方法（方法的定义），则可以依靠以下的语法形式：

访问类中的属性：对象.属性 ;

调用类中的方法：对象.方法(实际参数列表) ;

1.3、创建对象内存分析

1.3.1、栈

Java栈的区域很小 , 大概2m左右 , 特点是存取的速度特别快

栈存储的特点是, 先进后出

存储速度快的原因:

栈内存, 通过 '栈指针' 来创建空间与释放空间 !

指针向下移动, 会创建新的内存, 向上移动, 会释放这些内存 !

这种方式速度特别快 , 仅次于PC寄存器 !

但是这种移动的方式, 必须要明确移动的大小与范围 ,

明确大小与范围是为了方便指针的移动 , 这是一个对于数据存储的限制, 存储的数据大小是固定的 , 影响了程序的灵活性 ~

所以我们把更大部分的数据存储到了堆内存中

存储的是:

基本数据类型的数据以及引用数据类型的引用!

例如:

int a =10;

Person p = new Person();

10存储在栈内存中 , 第二句代码创建的对象的引用(p)存在栈内存中

1.3.2、堆

存放的是类的对象

. Java是一个纯面向对象语言, 限制了对象的创建方式:

所有类的对象都是通过new关键字创建

new关键字, 是指告诉JVM , 需要明确的去创建一个新的对象 , 去开辟一块新的堆内存空间:

堆内存与栈内存不同, 优点在于

我们创建对象时 , 不必关注堆内存中需要开辟多少存储空间 , 也不需要关注内存占用时长 !

堆内存中内存的释放是由GC(垃圾回收器)完成的

垃圾回收器回收堆内存的规则:

当栈内存中不存在此对象的引用时,则视其为垃圾 , 等待垃圾回收器回收 !

例如:

Person p0 = new Person();

Person p1 = p0;

Person p2 = new Person();

1.3.3、方法区

存放的是

- 类信息

- 静态的变量

- 常量

- 成员方法

方法区中包含了一个特殊的区域 ( 常量池 )(存储的是使用static修饰的成员)

1.3.4、PC寄存器

PC寄存器保存的是 当前正在执行的 JVM指令的地址 !

在Java程序中, 每个线程启动时, 都会创建一个PC寄存器 !

1.3.5、本地方法栈

保存本地(native)方法的地址 !

1.4、构造方法(构造器)

1.4.1、回顾对象创建

Person p = new Person();

在右侧Person后面出现的小括号, 其实就是在调用构造方法 !

1.4.2、概述

作用：用于对象初始化。

执行时机：在创建对象时,自动调用

特点：

所有的Java类中都会至少存在一个构造方法

如果一个类中没有明确的编写构造方法, 则编译器会自动生成一个无参的构造方法, 构造方法中没有任何的代码！

如果自行编写了任意一个构造器, 则编译器不会再自动生成无参的构造方法。

1.4.3、定义格式

定义的格式:

与普通方法基本相同, 区别在于: 方法名称必须与类名相同, 没有返回值类型的声明 !

案例：

public class Demo3{

         public static void main(String[] args){

                   Person p = new Person();

                   p = new Person(); p = new Person();

                  p = new Person();

}

}

class Person{

          public Person(){

                   System.out.println("对象创建时,此方法调用");

}

}

1.4.4、构造方法设计

建议自定义无参构造方法，不要对编译器形成依赖，避免错误发生。

当类中有非常量成员变量时，建议提供两个版本的构造方法，一个是无参构造方法，一个是全属性做参数的构造方法。当类中所有成员变量都是常量或者没有成员变量时，建议不提供任何版本的构造。

1.5、方法的重载

方法名称相同, 参数类型或参数长度不同, 可以完成方法的重载 !

方法的重载与返回值无关!

方法的重载 ,可以让我们在不同的需求下, 通过传递不同的参数调用方法来完成具体的功能。

1.6、构造方法的重载

一个类, 可以存在多个构造方法 :

参数列表的长度或类型不同即可完成构造方法的重载 ~

构造方法的重载 ,可以让我们在不同的创建对象的需求下, 调用不同的方法来完成对象的初始化!

1.7、匿名对象

没有对象名称的对象就是匿名对象。匿名对象只能使用一次，因为没有任何的对象引用，所以将称为垃圾，等待被G·C回收。只使用一次的对象可以通过匿名对象的方式完成，这一点在以后的开发中将经常使用到。

第二章面向对象进阶

2.1、封装 private

我们观察如下代码：

class Person{
private String name ; // 表示姓名
private int age ; // 表示年龄
void tell(){
System.out.println("姓名：" + name + "；年龄：" + age) ;
}
};
public class Demo{
public static void main(String args[]){
Person per = new Person() ;
per.name = "张三" ;
per.age = -30 ;
per.tell() ;
}
};

以上的操作代码并没有出现了语法错误，但是出现了逻辑错误（年龄-30岁）

在开发中，为了避免出现逻辑错误，我们建议对所有属性进行封装，并为其提供setter及getter方法进行设置和取得操作。



public class Demo2 {
    public static void main(String[] args) {
        Person1 per = new Person1() ;
        per.setName("张三") ;
        per.setAge(30) ;
        per.tell() ;
    }
}
class Person1{
    private String name ; // 表示姓名
    private int age ; // 表示年龄
    void tell(){
        System.out.println("姓名：" + getName() + "；年龄：" + getAge()) ;
    }
    public void setName(String str){
        name = str ;
    }
    public void setAge(int a){
        if(a>0&&a<150)
            age = a ;
    }
    public String getName(){
        return name ;
    }
    public int getAge(){
        return age ;
    }
};

结果：年龄无法设值，输出默认值0。

2.2、this

在Java基础中，this关键字是一个最重要的概念。使用this关键字可以完成以下的操作：

· 调用类中的属性 ·

调用类中的方法或构造方法 ·

表示当前对象

2.3、static

概述:

static表示“静态”的意思，可以用来修饰成员变量和成员方法(后续还会学习静态代码块和静态内部类)。

static的主要作用在于创建独立于具体对象的域变量或者方法

简单理解：

被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。

并且不会因为对象的多次创建而在内存中建立多份数据

重点:

1. 静态成员在类加载时加载并初始化。

2. 无论一个类存在多少个对象 , 静态的属性, 永远在内存中只有一份( 可以理解为所有对象公用 )

3. 在访问时：静态不能访问非静态 , 非静态可以访问静态 !

2.4、代码块

①普通代码块

在执行的流程中出现的代码块，我们称其为普通代码块。

②构造代码块

在类中的成员代码块，我们称其为构造代码块，在每次对象创建时执行，执行在构造方法之前。

③静态代码块

在类中使用static修饰的成员代码块，我们称其为静态代码块，在类加载时执行。每次程序启动到关闭，只会执行一次的代码块。

④同步代码块

在后续多线程技术中学习。

面试题：构造方法与构造代码块以及静态代码块的执行顺序：

静态代码块 --> 构造代码块 --> 构造方法

2.5、包

2.5.1. 包介绍

1、把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。

2、包如同文件夹一样，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。

3、包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

2.5.2. 包的使用规则

- 包中java文件的定义：

在.java文件的首部，必须编写类所属哪个包，格式：

package 包名;

- 包的定义：

通常由多个单词组成，所有单词的字母小写，单词与单词之间使用.隔开，一般命名为“com.公司名.项目名.模块名....”。

-规范由来：由于Java面向对象的特性，每名Java开发人员都可以编写属于自己的Java Package，为了保障每个Java Package命名的唯一性，在最新的Java编程规范中，要求开发人员在自己定义的包名前加上唯一的前缀。由于互联网上的域名称是不会重复的，所以多数开发人员采用自己公司在互联网上的域名称作为自己程序包的唯一前缀。例如： com.java.xxx

2.5.3 import 关键字

import 包名.类名;

2.6、权限修饰符

2.7、main方法详解

main()方法一直写到了今天：

public static void main(String args[])

以上的各个参数的含义如下： ·

public：表示公共的内容，可以被所有操作所调用 ·

static：表示方法是静态的，可以由类名称直接调用。java StaticDemo09 ·

void：表示没有任何的返回值操作 ·

main：系统规定好的方法名称。如果main写错了或没有，会报错：NoSuchMethodError: main ·

String[] args：字符串数组，接收参数的

public class StaticDemo10{
public static void main(String args[]){
for(int i=0;i<args.length;i++){
System.out.println(args[i]) ;
}
}
}

所有的参数在执行类的时候以空格进行分割。

java SaticDemo10 1 2 3 4 5 6 7

但是，如果现在我要输入的是以下几种参数“hello world”、“hello vince”、“hello mjw”。

因为以空格分割，所以以上的三组参数会当做六组参数输入，那么此时如果要想完成有空格的内容输入，则参数需要使用“"”括起来。

java StaticDemo10 "hello world" "hello vince" "hello mjw"

2.8、单例设计模式

单例设计模式是我们学习的第一个设计模式，也是比较重要的一个设计模式，单例设计模式会伴随这你的开发生涯，不管你是初级程序员，还是以后晋级到高级程序员，你都会接触到单例设计模式，今天，我们就学习单例设计模式的两种实现方式。

单例设计模式：保证程序在内存中只有一个对象存在（被程序所共享)

单例设计模式的两种实现方式：

一、懒汉式：随着类的加载在内存中对象为null，当调用 getInstance 方法时才创建对象（延迟加载）

二、饿汉式：随着类的加载直接创建对象（推荐开发中使用）

单例设计模式的实现步骤：

1．保证一个类只有一个实例，实现方式：构造方法私有化

2．必须要自己创建这个实例，实现方式：在本类中维护一个本类对象（私有，静态）

3．必须向整个程序提供这个实例，实现方式：对外提供公共的访问方式（getInstance方法，静态）

懒汉式实现如下：

懒汉式实现如下：
class Single{
private Single(){}
private static Single s1 = null;
public static Single getInstance(){
if(s1 == null){
s1 = new Single();
}
return s1;
}
}

饿汉式实现如下：

饿汉式实现如下：
class Single2{
private Single2(){}
private static Single2 s = new Single2();
public static Single getInstance(){
return s;
}
void print(){
System.out.println("Hello World!");
}
}

单例模式应用场景：

1. Windows的Task Manager（任务管理器）就是很典型的单例模式（这个很熟悉吧），想想看，是不是呢，你能打开两个windows task manager吗？不信你自己试试看哦~

2. windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。

3. 网站的计数器，一般也是采用单例模式实现，否则难以同步。

任务：

通过类描述衣服，每个衣服对象创建时需要自动生成一个序号值。要求：每个衣服的序号是不同的，且是依次递增 1 的。



public class Demo3 {
    public static void main(String[] args) {
        Clo c1=new Clo();
        Clo c2=new Clo();
        Clo c3=new Clo();
    }

}
class Clo{
    static int num=1;
    public Clo(){

        System.out.println("第"+num+"件衣服");
        num++;
    }

}

第三章面向对象高级

1.1 抽象类

1.1.1概念

抽象类必须使用abstract class声明一个抽象类中可以没有抽象方法。抽象方法必须写在抽象类或者接口中。格式：

abstract class 类名{

// 抽象类

}

1.1.2 抽象方法

只声明而未实现的方法称为抽象方法（未实现指的是：没有“{}”方法体），抽象方法必须使用abstract关键字声明。格式：

abstract class 类名{ // 抽象类

public abstract void 方法名() ; // 抽象方法，只声明而未实现

}

1.1.3 不能被实例化

在抽象类的使用中有几个原则： ·

抽象类本身是不能直接进行实例化操作的，即：不能直接使用关键字new完成。 ·

一个抽象类必须被子类所继承，被继承的子类（如果不是抽象类）则必须覆写(重写)抽象类中的全部抽象方法。

1.1.4 常见问题

1、抽象类能否使用final声明？

不能，因为final属修饰的类是不能有子类的，而抽象类必须有子类才有意义，所以不能。 2、抽象类能否有构造方法？

能有构造方法，而且子类对象实例化的时候的流程与普通类的继承是一样的，都是要先调用父类中的构造方法（默认是无参的），之后再调用子类自己的构造方法。

1.1.5 抽象类和普通类的区别

1、抽象类必须用public或protected修饰(如果为private修饰，那么子类则无法继承，也就无法实现其抽象方法）。默认缺省为 public

2、抽象类不可以使用new关键字创建对象，但是在子类创建对象时，抽象父类也会被JVM实例化。

3、如果一个子类继承抽象类，那么必须实现其所有的抽象方法。如果有未实现的抽象方法，那么子类也必须定义为 abstract类

2.1 接口

2.1.1 概念

如果一个类中的全部方法都是抽象方法，全部属性都是全局常量，那么此时就可以将这个类定义成一个接口。

定义格式：

interface 接口名称{

全局常量 ;

抽象方法 ;

}

2.1.2 面向接口编程思想

这种思想是接口是定义（规范，约束）与实现（名实分离的原则）的分离。

优点：

1、降低程序的耦合性

2、易于程序的扩展

3、有利于程序的维护

2.1.3 全局常量和抽象方法的简写

因为接口本身都是由全局常量和抽象方法组成，所以接口中的成员定义可以简写：

1、全局常量编写时，可以省略public static final 关键字，例如：

public static final String INFO = "内容" ;

简写后： String INFO = "内容" ;

2、抽象方法编写时，可以省略 public abstract 关键字，例如：

public abstract void print() ;

简写后： void print() ;

2.1.4 接口的实现 implements

接口可以多实现：

格式：

class 子类 implements 父接口1,父接口2...{

}

以上的代码称为接口的实现。那么如果一个类即要实现接口，又要继承抽象类的话，则按照以下的格式编写即可：

class 子类 extends 父类 implements 父接口1,父接口2...{ }

2.1.5 接口的继承

接口因为都是抽象部分，不存在具体的实现，所以允许多继承,例如：

interface C extends A,B{ }

注意：

如果一个接口要想使用，必须依靠子类。子类（如果不是抽象类的话）要实现接口中的所有抽象方法。

2.1.6 接口和抽象类的区别

1、抽象类要被子类继承，接口要被类实现。

2、接口只能声明抽象方法，抽象类中可以声明抽象方法，也可以写非抽象方法。

3、接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。

4、抽象类使用继承来使用，无法多继承。接口使用实现来使用，可以多实现

5、抽象类中可以包含static方法，但是接口中不允许（静态方法不能被子类重写，因此接口中不能声明静态方法）

6、接口不能有构造方法，但是抽象类可以有

3.1 多态

3.1.1 概念

多态：就是对象的多种表现形式，（多种体现形态）

3.1.2 多态的体现

对象的多态性，从概念上非常好理解，在类中有子类和父类之分，子类就是父类的一种形态，对象多态性就从此而来。

ps: 方法的重载和重写也是多态的一种，不过是方法的多态（相同方法名的多种形态）。

重载：一个类中方法的多态性体现 .

重写：子父类中方法的多态性体现。

3.1.3 多态的使用：对象的类型转换

类似于基本数据类型的转换： ·

向上转型：将子类实例变为父类实例

- 格式：父类父类对象 = 子类实例；

· 向下转型：将父类实例变为子类实例

- 格式：子类子类对象 = （子类）父类实例；

4.1 instanceof

作用：判断某个对象是否是指定类的实例，则可以使用instanceof关键字

格式：实例化对象 instanceof 类 //此操作返回boolean类型的数据

5.1 Object类

5.1.1 概念

Object类是所有类的父类（基类），如果一个类没有明确的继承某一个具体的类，则将默认继承Object类。

例如我们定义一个类：

public class Person{ }

其实它被使用时是这样的：

public class Person extends Object{ }

5.1.2 Object的多态

使用Object可以接收任意的引用数据类型

5.1.3 toString

建议重写Object中的toString方法。此方法的作用：返回对象的字符串表示形式。 Object的toString方法，返回对象的内存地址

5.1.4 equals

建议重写Object中的equals(Object obj)方法，此方法的作用：指示某个其他对象是否“等于”此对象。 Object的equals方法：实现了对象上最具区别的可能等价关系; 也就是说，对于任何非空引用值x和y ，当且仅当 x和y引用同一对象（ x == y具有值true ）时，此方法返回true 。

equals方法重写时的五个特性：

自反性：对于任何非空的参考值x ， x.equals(x)应该返回true 。

对称性：对于任何非空引用值x和y ， x.equals(y)应该返回true当且仅当y.equals(x)回报true 。

传递性：对于任何非空引用值x ， y和z ，如果x.equals(y)回报true个y.equals(z)回报true ，然后 x.equals(z)应该返回true 。

一致性：对于任何非空引用值x和y ，多次调用x.equals(y)始终返回true或始终返回false ，前提是未修改对象上的equals比较中使用的信息。

非空性：对于任何非空的参考值x ， x.equals(null)应该返回false 。

6.1 内部类

6.1.1 概念

在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。

广泛意义上的内部类一般来说包括这四种：

1、成员内部类 2、局部内部类 3、匿名内部类 4、静态内部类

6.1.2 成员内部类

成员内部类是最普通的内部类，它的定义为位于另一个类的内部，形如下面的形式：

class Outer {
private double x = 0;
public Outer(double x) {
this.x = x;
}
class Inner { //内部类
public void say() {
System.out.println("x="+x);
}
}
}

特点：成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）。

不过要注意的是，当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员，需要以下面的形式进行访问：

外部类.this.成员变量

外部类.this.成员方法

外部使用成员内部类

Outter outter = new Outter(); Outter.Inner inner = outter.new Inner();

6.1.3 局部内部类

局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。

class Person{
public Person() {
}
}
匿名内部类
注意：
静态内部类
class Man{
public Man(){
}
public People getPerson(){
class Student extends People{ //局部内部类
int age =0;
}
return new Student();
}
}

注意:局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。

6.1.4 匿名内部类

匿名内部类由于没有名字，所以它的创建方式有点儿奇怪。创建格式如下：

new 父类构造器（参数列表）|实现接口（） { //匿名内部类的类体部分 }

在这里我们看到使用匿名内部类我们必须要继承一个父类或者实现一个接口，当然也仅能只继承一个父类或者实现一个接口。同时它也是没有class关键字，这是因为匿名内部类是直接使用new来生成一个对象的引用。当然这个引用是隐式的。

注意：

1、使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或者实现一个接口。

2、匿名内部类中是不能定义构造函数的。

3、匿名内部类中不能存在任何的静态成员变量和静态方法。

4、匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。

5、匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。

6、只能访问final型的局部变量

6.1.5 静态内部类

静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。静态内部类是不需要依赖于外部类对象的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法

public class Test {
public static void main(String[] args) {
Outter.Inner inner = new Outter.Inner();
}
}
class Outter {
public Outter() {
}
static class Inner {
public Inner() {
}
}
}

7.1 包装类

7.1.1 概述

在Java中有一个设计的原则“一切皆对象”，那么这样一来Java中的一些基本的数据类型，就完全不符合于这种设计思想，因为Java中的八种基本数据类型并不是引用数据类型，所以Java中为了解决这样的问题，引入了八种基本数据类型的包装类。

以上的八种包装类，可以将基本数据类型按照类的形式进行操作。

但是，以上的八种包装类也是分为两种大的类型的： ·

Number：Integer、Short、Long、Double、Float、Byte都是Number的子类表示是一个数字。 ·

Object：Character、Boolean都是Object的直接子类。

7.1.2 装箱和拆箱操作

以下以Integer和Float为例进行操作

将一个基本数据类型变为包装类，那么这样的操作称为装箱操作。

将一个包装类变为一个基本数据类型，这样的操作称为拆箱操作，

因为所有的数值型的包装类都是Number的子类，Number的类中定义了如下的操作方法，以下的全部方法都是进行拆箱的操作。

装箱操作：

在JDK1.4之前，如果要想装箱，直接使用各个包装类的构造方法即可，例如：

int temp = 10 ; // 基本数据类型

Integer x = new Integer(temp) ; // 将基本数据类型变为包装类

在JDK1.5，Java新增了自动装箱和自动拆箱，而且可以直接通过包装类进行四则运算和自增自建操作。例如：

Float f = 10.3f ; // 自动装箱

float x = f ; // 自动拆箱

System.out.println(f * f) ; // 直接利用包装类完成

System.out.println(x * x) ; // 直接利用包装类完成

7.1.3 字符串转换

使用包装类还有一个很优秀的地方在于：可以将一个字符串变为指定的基本数据类型，此点一般在接收输入数据上使用较多。

在Integer类中提供了以下的操作方法：

public static int parseInt(String s) ：将String变为int型数据

注意：将int转String

        String str = String.valueOf(num);

在Float类中提供了以下的操作方法：

public static float parseFloat(String s) ：将String变为Float

在Boolean 类中提供了以下操作方法：

public static boolean parseBoolean(String s) ：将String变为boolean

8.1 可变参数

一个方法中定义完了参数，则在调用的时候必须传入与其一一对应的参数，但是在JDK 1.5之后提供了新的功能，可以根据需要自动传入任意个数的参数。

语法：

返回值类型方法名称(数据类型…参数名称){ //参数在方法内部，以数组的形式来接收 }

注意：可变参数只能出现在参数列表的最后。

9.1 递归

递归，在数学与计算机科学中，是指在方法的定义中使用方法自身。也就是说，递归算法是一种直接或者间接调用自身方法的算法。

递归流程图如下:

终极任务：

自定义一个类，命名为 MyList，
类中包含属性：Object[] element;
定义如下几个方法：
1. 增加方法 add ：可以向数组属性中依次存储 Object，数
组内容存满时，需实现动态扩容（详解在下面）。参考: Boolean add(Object
obj)
2. 删除方法 remove ：可以根据数据或下标，从数组属性
中删除 Object 数据，删除后，数组后续元素需前移。参考:void remove(Object
obj) 或 void remove(Integer index)
3. 查询方法 get ：方法传入下标，返回数组中指定下标的
数据。
参考:Object get(Integer index)
4. 当前存储数据量 size ：获取当前存储的有效数据长度
参考:size=数组.length


import java.util.Arrays;
import java.util.Scanner;

public class MyList {
    public static void main(String[] args) {
        MyList a1 = new MyList();
        Scanner input = new Scanner(System.in);
        a1.element = new Object[0];
        while (true) {
            System.out.println("请输入你要进行的操作的序号：1-增加数据；2-删除数据；3-查询数组内某下标的数据；4-得到数组的有效长度");
            int y = input.nextInt();
            if (y == 1) {
                System.out.println("请输入你要录入的新内容：");
                String x = input.next();
                a1.add(x);
            } else if (y == 2) {
                System.out.println("1-删除的是指定下标数据，2-删除指定内容");
                int o = input.nextInt();
                if (o == 1) {
                    System.out.println("请输入你要删除的数组下标：");
                    int x = input.nextInt();
                    a1.remove(x);
                } else if (o == 2) {
                    System.out.println("请输入你要删除删除的数组内容：");
                    String x = input.next();
                    a1.remove(x);
                }

            } else if (y == 3) {
                System.out.println("请输入你要查询的数组下标：");
                int x = input.nextInt();
                a1.get(x);
            } else if (y == 4) {
                System.out.println("有效数组长度为:" + a1.size());
            }
        }
    }

    static Object[] element;

    public static Boolean add(Object obj) {
        if (size() < element.length) {
            element[size()] = obj;
        } else if (size() == element.length) {
            // 复制原数组内容到新的大数组中
            Object[] element2 = new Object[element.length + 1];
            for (int i = 0; i < element.length; i++) {
                // 给新数组输入原数据
                element2[i] = element[i];
            }
            // 给新数组输入新的数据
            element2[element.length] = obj;
            // 将原数据的名字代替新的数组名字1
            element = element2;
        } else {
            System.out.println("发生了未知错误！");
        }
        System.out.println(Arrays.toString(element));
        return null;
    }

    /**
     * 删除内容
     * @param obj
     */
    public static void remove(String obj) {
        int n = 0;
        for (int i = 0; i < size(); i++) {
            // 检索数组,如果数据相同则删除数据，并执行相关后续处理
            if (element[i].equals(obj)) {
                for (int j = i; j < size() - 1; j++) {
                    // 检索数组，执行数据前移，同时也替换要删除的数据
                    element[i] = element[i + 1];
                }
                // 清除最后一位的重复数据
                element[size() - 1] = null;
            }
        }
        System.out.println("数据删除成功，后续数据已按顺序前移补齐空位。");
        System.out.println(Arrays.toString(element));

    }

    /**
     * 删除下标
     * @param index
     */
    void remove(int index) {
        for (int i = index; i < size() - 1; i++) {
            // 检索有效长度，并对后续数据前移
            element[i] = element[i + 1];
        }
        // 清除最后一位的重复数据
        element[size() - 1] = null;
        System.out.println("数据删除成功，后续数据已按顺序前移补齐空位。");
        System.out.println(Arrays.toString(element));
    }

    public static Object get(Integer index) {
        if (index >= 0 && index < element.length) {
            System.out.println(element[index]);
        } else {
            System.out.println("你输入的下标数据错误。");
        }
        return index;

    }

    public static int size() {
        int n = 0;
        // 设置有效长度计数器
        for (int i = 0; i < element.length; i++) {
            // 检索数组
            if (element[i] == null) {
                // 假如数组当前下标为无，则不计算有效长度
            } else {
                n++;
            }
        }
        return n;

    }
}

输出结果：

第四章异常处理

4.1 目标

1. 明确什么是异常（重点）
2. 能辨识出常见的异常及其含义。（熟悉+）

3. 理解异常产生的原理（了解）

4. 能处理异常（重点）

5. 能够自定义异常类型（熟悉）

4.2 什么是异常？

异常是在程序中导致程序中断运行的一种指令流。

例如，现在有如下的操作代码：

public class ExceptionDemo01{
public static void main(String argsp[]){
int i = 10 ;
int j = 0 ;
System.out.println("============= 计算开始 =============") ;
int temp = i / j ; // 进行除法运算
System.out.println("temp = " + temp) ;
System.out.println("============= 计算结束 =============") ;
}
};

运行结果：

============= 计算开始 =============

Exception in thread "main" java.lang.ArithmeticException: / by zero at ExceptionDemo01.main(ExceptionDemo01.java:6)

以上的代码在“int temp = i / j ;”位置处产生了异常，一旦产生异常之后，异常之后的语句将不再执行了，所以现在的程序并没有正确的执行完毕之后就退出了。

那么，为了保证程序出现异常之后仍然可以正确的执行完毕，所以要采用异常的处理机制.

4.3 处理异常

如果要想对异常进行处理，则必须采用标准的处理格式，处理格式语法如下：

try{

// 有可能发生异常的代码段

}catch(异常类型1 对象名1){

// 异常的处理操作

}catch(异常类型2 对象名2){

// 异常的处理操作

} ...

finally{

// 异常的统一出口

}

4.3.1 try+catch的处理流程

1、一旦产生异常，则系统会自动产生一个异常类的实例化对象。

2、那么，此时如果异常发生在try语句，则会自动找到匹配的catch语句执行，如果没有在try语句中，则会将异常抛出.

3、所有的catch根据方法的参数匹配异常类的实例化对象，如果匹配成功，则表示由此catch进行处理。

4.3.2 finally

在进行异常的处理之后，在异常的处理格式中还有一个finally语句，那么此语句将作为异常的统一出口，不管是否产生了异常，最终都要执行此段代码

4.4 异常体系结构

异常指的是Exception ， Exception类，在Java中存在一个父类Throwable（可能的抛出） Throwable存在两个子类：

1.Error：表示的是错误，是JVM发出的错误操作,只能尽量避免，无法用代码处理。

2.Exception：一般表示所有程序中的错误，所以一般在程序中将进行try…catch的处理。

多异常捕获的注意点：

1、捕获更粗的异常不能放在捕获更细的异常之前。

2、如果为了方便，则可以将所有的异常都使用Exception进行捕获。

特殊的多异常捕获写法：

catch(异常类型1 |异常类型2 对象名){

//表示此块用于处理异常类型1 和异常类型2 的异常信息 }

4.5 throws关键字

在程序中异常的基本处理已经掌握了，但是随异常一起的还有一个称为throws关键字，此关键字主要在方法的声明上使用，表示方法中不处理异常，而交给调用处处理。格式：

返回值方法名称()throws Exception{ }

4.6 throw关键字

throw关键字表示在程序中人为的抛出一个异常，因为从异常处理机制来看，所有的异常一旦产生之后，实际上抛出的就是一个异常类的实例化对象，那么此对象也可以由throw直接抛出。

代码： throw new Exception("抛着玩的。") ;

4.7 RuntimeExcepion与Exception的区别

注意观察如下方法的源码： Integer类：

public static int parseInt(String text)throws NumberFormatException

此方法抛出了异常，但是使用时却不需要进行try。。。catch捕获处理，原因：
因为NumberFormatException并不是Exception的直接子类，而是RuntimeException的子类，只要是 RuntimeException的子类，则表示程序在操作的时候可以不必使用try…catch进行处理，如果有异常发生，则由JVM进行处理。当然，也可以通过try catch处理。