Java基础回顾系列-第二天-面向对象编程

最新推荐文章于 2023-02-09 09:48:13 发布

置顶 qiqitrue

最新推荐文章于 2023-02-09 09:48:13 发布

阅读量258

点赞数

分类专栏： Java基础文章标签： java java基础面向对象

本文链接：https://blog.csdn.net/u013474568/article/details/85259850

版权

Java基础专栏收录该内容

11 篇文章 1 订阅

订阅专栏

面向对象编程

Java类核心开发结构

类名称一定要有意义，可以明确的描述某一类事物；
类之中的所有属性必须使用private封装，同时提供有setter/getter方法；
类之中可以提供多个构造方法，但是必须保留有无参构造方法；
类之中不允许出现任何的输出语法，所有的内容获取必须返回；
【非必须】可以提供一个获取对象的详细信息

面向对象

参见博文Java面向对象概述 https://www.cnblogs.com/jingzhenhua/p/5885527.html
参见博文 http://cmsblogs.com/?p=3740

封装

封装是面向对象编程的核心思想，将对象的属性和行为封装起来，而将对象的属性和行为封装起来的载体就是类，类通常对客户隐藏其实现细节，这就是封装的思想。

封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。适当的封装可以让程序代码更容易理解与维护，也加强了程序代码的安全性。

封装的优点:

良好的封装能够减少耦合。
类内部的结构可以自由修改。
可以对成员变量进行更精确的控制。
隐藏信息，实现细节。

继承

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

继承的特性:

子类拥有父类非 private 的属性、方法。
子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
子类可以用自己的方式实现父类的方法。
Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 A 类继承 B 类，B 类继承 C 类，所以按照关系就是 C 类是 B 类的父类，B 类是 A 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。
提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

多态

多态是同一个行为具有多个不同表现形式或形态的能力。
参见博文：https://www.cnblogs.com/chenssy/p/3372798.html

多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。

多态的优点

消除类型之间的耦合关系
可替换性
可扩充性
接口性
灵活性
简化性

多态存在的三个必要条件:

继承
重写
父类引用指向子类对象

多态的实现方式：

重写
接口
抽象类和抽象方法

抽象类abstract

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。
由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。
父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。
在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

在使用抽象类时需要注意几点：
1、抽象类不能被实例化，实例化的工作应该交由它的子类来完成，它只需要有一个引用即可。
2、抽象方法必须由子类来进行重写。
3、只要包含一个抽象方法的抽象类，该方法必须要定义成抽象类，不管是否还包含有其他方法。
4、抽象类中可以包含具体的方法，当然也可以不包含抽象方法。
5、子类中的抽象方法不能与父类的抽象方法同名。
6、abstract不能与final并列修饰同一个类。
7、abstract 不能与private、static、final或native并列修饰同一个方法。

接口interface

接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。
接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。
接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

接口是用来建立类与类之间的协议，它所提供的只是一种形式，而没有具体的实现。同时实现该接口的实现类必须要实现该接口的所有方法，通过使用implements关键字，他表示该类在遵循某个或某组特定的接口，同时也表示着“interface只是它的外貌，但是现在需要声明它是如何工作的”。
接口是抽象类的延伸，java了保证数据安全是不能多重继承的，也就是说继承只能存在一个父类，但是接口不同，一个类可以同时实现多个接口，不管这些接口之间有没有关系，所以接口弥补了抽象类不能多重继承的缺陷，但是推荐继承和接口共同使用，因为这样既可以保证数据安全性又可以实现多重继承。

抽象类与接口的区别

尽管抽象类和接口之间存在较大的相同点，甚至有时候还可以互换，但这样并不能弥补他们之间的差异之处。

抽象类和接口的区别

抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static inal 类型的。
接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
一个类只能继承一个抽象类，而一个类却可以实现多个接口。

深入分析类与对象

内存分析

堆内存： 保存的是对象的具体信息
栈内存： 保存的是一块堆内存的地址，即：通过地址找到堆内存，而后找到对象内容

继承extends

Java中继承是单继承，只有一个父类，可以有多个子类。
子类在继承父类的属性和方法的时候可以扩展自己的属性和方法。
继承父类的时候，父类必须有一个无参构造。
子类构造的时候会默认通过super()来调用父类的构造方法。初始化子类的时候，先调用父类的默认构造，再调用子类的构造。
调用父类的属性或方法可以通过super关键字。
在调用子类的方法时会先在子类中寻找那个方法，找到后调用成功，否则再去父类中找想要调用的方法。如果在子类中找到了那个方法，则子类重写了父类的方法。
用final修饰的类不能被继承。

重写(Override)与重载(Overload)

重写(Override)

重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！
重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。
重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常 IOException，但是在重写这个方法的时候不能抛出Exception 异常，因为 Exception 是 IOException 的父类，只能抛出 IOException 的子类异常。
在面向对象原则里，重写意味着可以重写任何现有方法。

方法的重写规则

参数列表必须完全与被重写方法的相同；
返回类型必须完全与被重写方法的返回类型相同；
访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。父类的成员方法只能被它的子类重写。
声明为final的方法不能被重写。声明为final的方法不能被重写。
声明为static的方法不能被重写，但是能够被再次声明。声明为static的方法不能被重写，但是能够被再次声明。
子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。
子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。
重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
构造方法不能被重写。构造方法不能被重写。
如果不能继承一个方法，则不能重写这个方法。如果不能继承一个方法，则不能重写这个方法。

重载(Overload)

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。
每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。
最常用的地方就是构造器的重载。

重载规则:

被重载的方法必须改变参数列表(参数个数或类型不一样)；
被重载的方法可以改变返回类型；
被重载的方法可以改变访问修饰符；
被重载的方法可以声明新的或更广的检查异常；
方法能够在同一个类中或者在一个子类中被重载。
无法以返回值类型作为重载函数的区分标准。

重写与重载之间的区别

区别点	重载方法	重写方法
参数列表	必须修改	一定不能修改
返回类型	可以修改	一定不能修改
异常	可以修改	可以减少或删除，一定不能抛出新的或者更广的异常
访问	可以修改	一定不能做更严格的限制（可以降低限制）

总结

方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载可以理解成多态的具体表现形式。

方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载(Overloading)。
方法重写是在子类存在方法与父类的方法的名字相同,而且参数的个数与类型一样,返回值也一样的方法,就称为重写(Overriding)。
方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。

this关键字

指向自己的引用。 可用于任何实例方法内指向当前对象，也可指向对其调用当前方法的对象，或者在需要当前类型对象引用时使用。
提示： 当一个类的属性（成员变量）名与访问该属性的方法参数名相同时，则需要使用 this 关键字来访问类中的属性，以区分类的属性和方法中的参数。

调用本类属性： 当成员变量和局部变量重名时，在方法中使用this时，表示的是该方法所在类中的成员变量。
调用本类方法(构造方法、普通方法)： this.()无参构造；this.xxx()方法调用。

static关键字

在Java中并不存在全局变量的概念，但是我们可以通过static来实现一个"伪全局"的概念，在Java中static表示"全局"或者"静态"的意思，用来修饰成员变量和成员方法，当然也可以修饰代码块。

Java把内存分为栈内存和堆内存，其中栈内存用来存放一些基本类型的变量、数组和对象的引用，堆内存主要存放一些对象。在JVM加载一个类的时候，若该类存在static修饰的成员变量和成员方法，则会为这些成员变量和成员方法在固定的位置开辟一个固定大小的内存区域，有了这些“固定”的特性，那么JVM就可以非常方便地访问他们。同时如果静态的成员变量和成员方法不出作用域的话，它们的句柄都会保持不变。同时static所蕴含“静态”的概念表示着它是不可恢复的，即在那个地方，你修改了，他是不会变回原样的，你清理了，他就不会回来了。
同时被static修饰的成员变量和成员方法是独立于该类的，它不依赖于某个特定的实例变量，也就是说它被该类的所有实例共享。所有实例的引用都指向同一个地方，任何一个实例对其的修改都会导致其他实例的变化。

总结： 无论是变量，方法，还是代码块，只要用static修饰，就是在类被加载时就已经”准备好了”,也就是可以被使用或者已经被执行，都可以脱离对象而执行。反之，如果没有static，则必须要依赖于对象实例。

static变量

static修饰的变量我们称之为静态变量，没有用static修饰的变量称之为实例变量，他们两者的区别是：
静态变量是随着类加载时被完成初始化的，它在内存中仅有一个，且JVM也只会为它分配一次内存，同时类所有的实例都共享静态变量，可以直接通过类名来访问它。
但是实例变量则不同，它是伴随着实例的，每创建一个实例就会产生一个实例变量，它与该实例同生共死。
所以我们一般在这两种情况下使用静态变量：对象之间共享数据、访问方便。

static方法

static修饰的方法我们称之为静态方法，我们通过类名对其进行直接调用。由于他在类加载的时候就存在了，它不依赖于任何实例，所以static方法必须实现，也就是说他不能是抽象方法abstract。
Static方法是类中的一种特殊方法，我们只有在真正需要他们的时候才会将方法声明为static。如Math类的所有方法都是静态static的。

static代码块

被static修饰的代码块，我们称之为静态代码块，静态代码块会随着类的加载一块执行，而且他可以随意放，可以存在于该了的任何地方。

代码块

在Java中，使用{}括起来的代码被称为代码块。使用率极低
根据其位置和声明的不同，可以分为：
局部代码块:局部位置,用于限定变量的生命周期。
构造代码块:在类中的成员位置,用{}括起来的代码。每次调用构造方法执行前，都会先执行构造代码块。
作用：可以把多个构造方法中的共同代码放到一起，对对象进行初始化。
静态代码块:在类中的成员位置,用{}括起来的代码,只不过它用static修饰了。
作用：一般是对类进行初始化。

String类特点分析

String类在java.lang包中，java使用String类创建一个字符串变量，字符串变量属于对象。
java把String类声明的final类，不能有子类。
String类对象创建后不能修改，由0或多个字符组成，包含在一对双引号之间。
1）String类是final类，也即意味着String类不能被继承，并且它的成员方法都默认为final方法。在Java中，被final修饰的类是不允许被继承的，并且该类中的成员方法都默认为final方法。
2）通过源码能发现String类中所有的成员属性，可以看出String类其实是通过char数组来保存字符串的。
3）String对象一旦被创建就是固定不变的了，对String对象的任何改变都不影响到原对象，相关的任何change操作都会生成新的对象

参见博文：深入理解Java中的String https://www.cnblogs.com/xiaoxi/p/6036701.html

字符串创建

字符串声明：String stringName;
字符串创建：stringName = new String(字符串常量);或stringName = 字符串常量;

String类常用方法

参见：String类常用方法

注解Annotation

@author 标明开发该类模块的作者，多个作者之间使用,分割
@version 标明该类模块的版本
@see 参考转向，也就是相关主题
@since 从哪个版本开始增加的
@param 对方法中某参数的说明，如果没有参数就不能写
@return 对方法返回值的说明，如果方法的返回值类型是void就不能写
@exception 对方法可能抛出的异常进行说明，如果方法没有用throws显式抛出的异常就不能写

@Override(重写)

只允许在重写父类方法的子类方法上。

@Deprecated(不赞成的)

可作用与类及方法上。

@SuppressWarnings(忽略警告)

可作用与类及方法上。

Object类

Object 是 Java 类库中的一个特殊类，也是所有类的父类。当一个类被定义后，如果没有指定继承的父类，那么默认父类就是 Object 类。

在这里插入图片描述
其中，equals() 方法和 getClass() 方法在 Java 程序中比较常用。

包装类

Java中的基本类型功能简单，不具备对象的特性，为了使基本类型具备对象的特性，所以出现了包装类，就可以像操作对象一样操作基本类型数据。

基本数据类型	包装类型
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

装箱、拆箱
注意：jdk9之后手动装箱类操作已经不推荐使用。Boolean b = new Boolean(true);可直接写成”Boolean b = true;

泛型T

参见博文Java 泛型详解
参见博文Java 泛型详解
或者回顾看魔乐科技李兴华基础系列的泛型视频。

所谓的泛型就是：类型的参数化
泛型是类型的一部分，类名+泛型是一个整体。
不使用泛型的弊端：
如果有泛型(需要使用泛型的时候)，不使用时，参数的类型会自动提升成Object类型，如果再取出来的话就需要向下强转，就可能发生类型转化异常(ClassCaseException)；不加泛型就不能在编译期限定向集合中添加元素的类型，导致后期的处理麻烦。

常见字母（见名知意）
T Type
K V Key Value
E Element

泛型的使用注意：

泛型只允许设置引用类型，不支持基本数据类型，如果现在要操作基本类型必须使用包装类；
泛型不支持继承，必须保持前后一致（比如这样是错误的：List<Object> list = new ArrayList<String>();
从JDK1.7开始，泛型实例化可以简化。

泛型的通配符(?)：
上限限定：比如定义方法的时候出现，public void getFunc(List<? extends Animal> an)，
那么表示这里的参数可以传入Animal，或者 Animal的子类
下限限定: 比如定义方法的时候出现，public void getFunc(Set<? super Animal> an ),
那么表示这里的参数可以传入Animal，或者Animal的父类

<? extends T>和<? super T>的区别
<? extends T>表示该通配符所代表的类型是T类型的子类。
<? super T>表示该通配符所代表的类型是T类型的父类。

泛型通配符

public class Box<T> {
   
  private T t;
 
  public void add(T t) {
    this.t = t;
  }
 
  public T get() {
    return t;
  }
 
  public static void main(String[] args) {
    Box<Integer> integerBox = new Box<Integer>();
    Box<String> stringBox = new Box<String>();
 
    integerBox.add(new Integer(10));
    stringBox.add(new String("菜鸟教程"));
 
    System.out.printf("整型值为 :%d\n\n", integerBox.get());
    System.out.printf("字符串为 :%s\n", stringBox.get());
  }
}

通配符?

类型通配符一般是使用?代替具体的类型参数。例如 List<?> 在逻辑上是List,List 等所有List<具体类型实参>的父类。

import java.util.*;
 
public class GenericTest {
     
    public static void main(String[] args) {
        List<String> name = new ArrayList<String>();
        List<Integer> age = new ArrayList<Integer>();
        List<Number> number = new ArrayList<Number>();
        
        name.add("icon");
        age.add(18);
        number.add(314);
 
        getData(name);
        getData(age);
        getData(number);
       
   }
 
   public static void getData(List<?> data) {
      System.out.println("data :" + data.get(0));
   }
}

2、类型通配符上限通过形如List来定义，如此定义就是通配符泛型值接受Number及其下层子类类型。

import java.util.*;
 
public class GenericTest {
     
    public static void main(String[] args) {
        List<String> name = new ArrayList<String>();
        List<Integer> age = new ArrayList<Integer>();
        List<Number> number = new ArrayList<Number>();
        
        name.add("icon");
        age.add(18);
        number.add(314);
 
        //getUperNumber(name);//1
        getUperNumber(age);//2
        getUperNumber(number);//3
       
   }
 
   public static void getData(List<?> data) {
      System.out.println("data :" + data.get(0));
   }
   
   public static void getUperNumber(List<? extends Number> data) {
          System.out.println("data :" + data.get(0));
       }
}

解析：在(//1)处会出现错误，因为getUperNumber()方法中的参数已经限定了参数泛型上限为Number，所以泛型为String是不在这个范围之内，所以会报错。
3、类型通配符下限通过形如 List<? super Number>来定义，表示类型只能接受Number及其三层父类类型，如Objec类型的实例。

泛型接口T

泛型子类传递

interface IMessage<T> {
	public String echo(T t) ;
}
class MessageImpl<S> implements IMessage<S> {
	public String echo(S t) {
		return "【ECHO】" + t ; 
	}
}
public class JavaDemo {
	public static void main(String args[]) {
		IMessage<String> msg = new MessageImpl<String>() ;
		System.out.println(msg.echo("www.mldn.cn")) ;
	}
}

子类限定类型

interface IMessage<T> {
	public String echo(T t) ;
}
// 实现类直接指定类型
class MessageImpl implements IMessage<String> {
	public String echo(String t) {
		return "【ECHO】" + t ; 
	}
}
public class JavaDemo {
	public static void main(String args[]) {
		IMessage<String> msg = new MessageImpl() ;
		System.out.println(msg.echo("www.mldn.cn")) ;
	}
}

泛型方法T

public class JavaDemo {
	public static void main(String args[]) {
		Integer num [] = fun(1,2,3) ;	// 传入了整数，泛型类型就是Integer
		for (int temp : num) {
			System.out.print(temp + "、") ;
		}
	}
	// 不能直接public static T[] fun(T ... args) 写，需要在返回的时候加上“T[]”进行泛型标注
	public static <T> T[] fun(T ... args) {
		return args ;
	}
}

包package

为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。Java 使用包（package）这种机制是为了防止命名冲突，访问控制，提供搜索和定位类（class）、接口、枚举（enumerations）和注释（annotation）等。
等同于文件夹。

单例设计模式

参见博文单例模式的五种实现方式

饿汉式

懒汉式

枚举Emum

类的对象只有有限个，确定的。举例如下：

星期：Monday(星期一)、…、Sunday(星期天)
线程状态：创建、就绪、运行、阻塞、死亡

当需要定义一组常量时，强烈建议使用枚举类。
枚举类的实现

JDK1.5之前需要自定义枚举类
JDK 1.5 新增的 enum 关键字用于定义枚举类

若枚举只有一个对象, 则可以作为一种单例模式的实现方式。

自定义枚举类

package javase.util;

public class TestMain {
	public static void main(String[] args) {
		Season spring = Season.SPRING;
		System.out.println("spring = " + spring);
	}
}

/**
 * 自定义枚举类JDK1.5之前
 * 1. 私有化类的构造器，保证不能在类的外部创建其对象
 * 2. 在类的内部创建枚举类的实例。声明为：public static final 
 * 3. 对象如果有实例变量，应该声明为private final，并在构造器中初始化
 */
class Season {
	private final String SEASONNAME;//季节的名称
	private final String SEASONDESC;//季节的描述

	private Season(String seasonName, String seasonDesc) {
		this.SEASONNAME = seasonName;
		this.SEASONDESC = seasonDesc;
	}

	public static final Season SPRING = new Season("春天", "春暖花开");
	public static final Season SUMMER = new Season("夏天", "夏日炎炎");
	public static final Season AUTUMN = new Season("秋天", "秋高气爽");
	public static final Season WINTER = new Season("冬天", "白雪皑皑");

	@Override
	public String toString() {
		return this.SEASONNAME + "-" + this.SEASONDESC;
	}
}

使用enum定义枚举类

使用说明：

使用 enum 定义的枚举类默认继承了 java.lang.Enum类，因此不能再继承其他类
枚举类的构造器只能使用 private 权限修饰符
枚举类的所有实例必须在枚举类中显式列出(, 分隔 ; 结尾)。列出的实例系统会自动添加 public static final 修饰
必须在枚举类的第一行声明枚举类对象

package javase.util;

public class TestMain {
	public static void main(String[] args) {
		// 返回枚举类型的对象数组。该方法可以很方便地遍历所有的枚举值。
		Season[] values = Season.values();
		for (int i = 0; i < values.length; i++) {
			// values[i] = SPRING
			System.out.println("values[i] = " + values[i]);
		}

		// 把一个字符串转为对应的枚举类对象。要求字符串必须是枚举类对象的“名字”。如不是，会有运行时异常：IllegalArgumentException
		Season spring = Season.valueOf("SPRING");
		// spring.name() = SPRING
		System.out.println("spring.name() = " + spring.name());
		// spring.ordinal() = 0
		System.out.println("spring.ordinal() = " + spring.ordinal());
	}
}

/**
 * 使用enum定义枚举类JDK1.5之后
 */
enum Season {
	SPRING("春天", "春暖花开"),
	SUMMER("夏天", "夏日炎炎"),
	AUTUMN("秋天", "秋高气爽"),
	WINTER("冬天", "白雪皑皑");

	private final String SEASONNAME;//季节的名称
	private final String SEASONDESC;//季节的描述

	private Season(String seasonName, String seasonDesc) {
		this.SEASONNAME = seasonName;
		this.SEASONDESC = seasonDesc;
	}
}

异常

public class ReturnExceptionDemo {
	public static void main(String[] args) {
		/*
		 * 进入方法A
		 * 用A方法的finally
		 * 制造异常
		 * 进入方法B
		 * 调用B方法的finally
		 */
		try {
			methodA();
		} catch (Exception e) {
			System.out.println(e.getMessage());
		}
		methodB();
	}

	static void methodA() {
		try {
			System.out.println("进入方法A");
			throw new RuntimeException("制造异常");
		} finally {
			System.out.println("用A方法的finally");
		}
	}

	static void methodB() {
		try {
			System.out.println("进入方法B");
			return;
		} finally {
			System.out.println("调用B方法的finally");
		}
	}
}

内部类

内部类不是很好理解，但说白了其实也就是一个类中还包含着另外一个类。
如同一个人是由大脑、肢体、器官等身体结果组成，而内部类相当于其中的某个器官之一，例如心脏：它也有自己的属性和行为（血液、跳动）显然，此处不能单方面用属性或者方法表示一个心脏，而需要一个类。而心脏又在人体当中，正如同是内部类在外部内当中。

Java内部类分为： 成员内部类、静态嵌套类、方法内部类、匿名内部类 。

内部类的共性:

内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。
内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否是private的。
内部类声明成静态的，就不能随便的访问外部类的成员变量了，此时内部类只能访问外部类的静态成员变量。

内部类的作用：
内部类其实严重破坏了良好的代码结构，但为什么还要使用内部类呢?
因为内部类可以随意使用外部类的成员变量（包括私有）而不用生成外部类的对象，这也是内部类的唯一优点。 如同心脏可以直接访问身体的血液，而不是通过医生来抽血。为了加深对Java内部类的理解，多想想内部类与外部类之间怎么转换的写法，我们可以体会出，写内部类会方便很多。

参考博文：Java内部类详解
参考博文：JAVA基础——内部类详解

成员内部类

内部类中最常见的就是成员内部类，也称为普通内部类。

在成员内部类中要注意两点，第一：成员内部类中不能存在任何static的变量和方法；第二：成员内部类是依附于外围类的，所以只有先创建了外围类才能够创建内部类。

package javase.util;

/**
 * 成员内部类
 */
public class MemberOuter {
    private static int i;// 静态成员变量
    private int j = 10;
    private int k =20;
    // 定义一个外部的静态方法
    public static void outer_f1(){
        System.out.println("内部使用外部outer_f1()方法");
    }

    public void outer_f2(){
        System.out.println("内部使用外部outer_f2()方法");
    }

    public void outer_f3(){//外部类方法可以直接使用new对内部类的使用
        System.err.println("进入outer_f3来取内部类方法成员");
        Inner inner = new Inner();
        inner.inner_f1();
    }

    class Inner {
//        static int inner_i = 100;//内部不允许定义静态变量
        int j = 100;
        int inner_i =1;
        int k =10;
        // 内部类与外部类方法重名
        void inner_f1(){
            System.out.println("可以直接访问外部类变量：  "+i);//得到初始值0
            System.out.println("在内部类中访问内部类的变量直接用 变量名(也可以用this.j): "+j);

            System.out.println("内部类使用外部类中与同类同名的实例变量用 外部名.this.变量名"+MemberOuter.this.j);
            System.out.println("内部类的k: "+k);//内部类变量
            System.out.println("内部取外部类用"+MemberOuter.this.k); //取外部类则要外部类.this.变量名
            outer_f1();//不需要外部类名.this
            outer_f2();
        }
    }

    public static void main(String[] args) {
        //MemberOuter.Inner in = new MemberOuter().new Inner();
        //in.inner_f1();
        //注释可写成
        MemberOuter m = new MemberOuter();
        m.outer_f3();
    }
}

package javase.util;

/**
 * 成员内部类
 */
public class Outer1 {
    private String name = "张三";
    class Inner1{ //内部类
        public void displayInner1(){
            System.out.println(name+"非静态内部类Inner1的displayInner1方法，可以直接访问非静态外部类的私有属性name="+name);
        }
    }

    public static void main(String[] args) {
        new Outer1().new Inner1().displayInner1();//非静态内部类Inner1的displayInner1方法，可以直接访问非静态外部类的私有属性
    }
}

package javase.util;

/**
 *  成员内部类
 */
public class Out {
    int i = 9;
    /**
     * 内部类
     */
    class In{
        public void display(){
            System.out.println("内部类对this的引用(相当于一个外部类的引用): "+Out.this.i);//内部类调用.this.变量
        }
    }

    public static void main(String[] args) {
        new Out().new In().display();//外部类引用内部类方法  外部类实例.内部类实例.方法
    }
}