第三章、第4节 面向对象高级

1、继承（extends）

示例代码1：

package com.java.demo1;
/**
 * 继承：
 * 继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，
 * 使得子类具有父类相同的行为。
 *
 * 格式：
 	class 父类{
 		
 	}
 	
 	class 子类 extends 父类{
 		
 	}
 */
public class Demo1{
    public static void main(String[] args){
        Student s = new Student();
        s.setName("小明");
        s.setAge(18);
        s.say();
    }
}
//人类
class Person{
    private String name;
    private int age;
    
    public Person(){
        super();
    }
    
    public Person(String name,int age){
        super();
        this.name = name;
        this.age = age;
    }
    
    public String getName(){
        return name;
    }
    
    public void setName(String name){
        this.name = name;
    }
    
    public int getAge(){
        return age;
    }
    
    public void setAge(int age){
        this.age = age;
    }
    
    public void say(){
        System.out.println("我是：" + name + "，我今年" + age "岁了");
    }
}
//学生类继承人类
class Student extends Person{
}

2、子类实例化内存分析

package com.java.demo1;
/**
 * 继承的限制：
 *	  java中只有单继承，多重继承，没有多继承。
 * 
 * 多重继承：
 *    相当于D继承C，C继承B，B继承A，...（一条线）（相当于每一个孩子只有一个父亲，每位父亲只有一个孩子）；
 *	  也可以是D继承B，C继承B，B继承A，...（树形结构）（相当于每一个孩子只有一个父亲，每位父亲可以有多个孩子）。
 *
 * 多继承：
 *    A同时可以继承多个类（相当于一个孩子有多个父亲，与实际不符）。（C++支持多继承，而java不支持多继承
 *    ，Java是通过多重继承间接支持类似的多继承）
 */
public class Demo1{
    public static void main(String[] args){
        Student s = new Student();
        s.setName("小明");
        s.setAge(18);
        s.say();
    }
}
//人类
class Person{ //对于没有继承其他类的类，默认继承Object类，Object是所有没有继承其他类的父亲，可以说是其他类的祖先。
    private String name;
    private int age;
    
    public Person(){
        super();//这里的super()用于调用Object的无参构造方法Object()（即：调用其父的无参构造器，即便super()不存在亦如此。）
    }
    
    public Person(String name,int age){
        super();//同理
        this.name = name;
        this.age = age;
    }
    
    public String getName(){
        return name;
    }
    
    public void setName(String name){
        this.name = name;
    }
    
    public int getAge(){
        return age;
    }
    
    public void setAge(int age){
        this.age = age;
    }
    
    public void say(){
        System.out.println("我是：" + name + "，我今年" + age "岁了");
    }
}
//学生类
class Student extends Person{
}
/**
 * 当创建子类对象时，内部的流程中会首先创建父类对象，把父类对象创建完毕后再创建子类对象，
 * 并且父类对象会作为子类对象的super存在。
 */

3、super详解

/**
 * super:
 *		① 通过super，可以访问父类构造方法。格式：super(无参)或super(有参)
 *			 调用super构造方法的代码，必须写在子类构造方法的第一行。
 *          （这里的super构造方法<==>父类构造方法）
 *		② 通过super，可以访问父类的属性。格式：super.父类属性名
 *
 *		③ 通过super，可以访问父类的方法。格式：super.父类方法名
 */
public class Demo1{
    public static void main(String[] args){
        Student s1 = new Student();
        s1.say();
        Student s2 = new Student("小明",18);
        s2.say();
    }
}
//人类
class Person{
    private String name;
    private int age;
    
    public Person(){
        
    }
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    public int getAge(){
        this.age = age;
    }
    public void setAge(int age){
        this.age = age;
    }
    
    public void say(){
        System.out.println("我是：" + name + "，我今年" + age + "岁了");
    }
}
//学生
class Student extends Person{
    public Student(){
        super("无名称",1);
    }
    public Student(String name,int age){
        super(name,age);
    }
}

4、重写（也可称其为覆盖）（Override）、重写与重载（Overload）的区别

package com.kaikeba.demo1;
/**
 * 重写规则：
 *	1、参数列表必须完全与被重写方法相同。
 *	2、返回类型必须完全与被重写方法的返回类型相同。
 *	3、访问权限不能比父类中被重写的方法的访问权限更低；例如：如果父类的一个方法被声明为public，
 *     那么在子类中重写该方法就不能声明为protected或private。
 *	4、父类的成员方法只能被它的子类重写。
 *	5、声明为static和private的方法不能被重写，但是能够被再次声明。
 *	
 *	再次声明总结：重写用于子类继承某个父类的方法时，不适子类这个程序的功能，因此把这个方法重写（覆盖）一遍。
 *              子类对象调用该方法执行时，仅执行子类重写的方法。
 *
 *	Java中重写（Override）与重载（Overload）的区别：
 *		1、发生的位置
 *			重载：一个类中
 *			重写：子父类中
 *		2、参数列表限制
 *			重载：必须不同
 *			重写：必须相同
 *		3、返回值类型：
 *			重载：与返回值类型无关
 *			重写：返回值类型必须一致
 *		4、访问权限：
 *			重载：与访问权限无关
 *			重写：子的访问权限 必须不能低于 父类的访问权限
 *		5、异常处理（暂不理解）：
 *			重载：与异常无关
 *			重写：异常范围可以更小，但是不能抛出新的异常。
 */
public class Demo1{
    public static void main(String[] args){
        Student s = new Student();
        s.say();
    }
}
//人类
class Person{
    public void say(){
        System.out.println("锄禾日当午，汗滴禾下土");
    }
}
//学生类
class Student extends Person{
    //重写父的say()方法（使继承的say()不在执行！！！，而是执行自己的say()方法）
    public void say(){
        System.out.println("床前明月光，玻璃好上霜，要不及时擦，整不好得脏！");
    }
}
/**
 * 案例：
 *    向服务器存储和取出数据时，通过父类和子类执行的指令不同（借助重写的原理），
 *    父类可以向数据库中的存储数据，子类可以取出数据库中的数据。
 */

5、final关键字

/**
 *	final关键字：
 *		final用于修饰属性、变量。
 *			变量成为了常量，无法对其再次进行赋值。
 *			final修饰的局部变量，只能赋值一次（可以先声明后赋值）
 *			final修饰的成员属性，必须在声明时赋值。
 *			全局常量（public static final），仅在方法外类中或接口中声明。
 *			
 *			常量的命名规范：
 *				由1个或多个单词组成，单词与单词之间必须使用下划线隔开，单词中所有字母大写。
 *				例如：SQL_INSERT
 *		final用于修饰类:
 *			final修饰的类，不可以被继承。
 *		final用于修饰方法：
 *			final修饰的方法，不能被子类重写。
 *
 *	全局常量（public static final）格式：public static final 数据类型 常量名 = 初始值;
 */
public class Demo1{
    public static final int SQL_INSERT = 1234;	//全局常量SQL_INSERT
	static final int A = 10;	//成员属性A
    public static void main(String[] args){
        final int B = 20;		//局部变量B
    }
}

6、抽象类（抽象类中的方法是模糊的）

6.1 概念

抽象类必须使用abstract class声明
    一个抽象类中可以没有抽象方法，抽象方法必须写在 抽象类 或者 接口 中。
    
格式：
    abstract class 类名{	//抽象类
        
    }
//用于不确定的类（成员属性和方法不确定）中！！！，用于捉摸不透的类中。。。

6.2 抽象方法

只声明而未实现的方法称为抽象方法（未实现指的是：没有“{}”方法体），抽象方法必须使用abstract关键字声明。
    
格式：
    abstract class 类名{	//抽象类
        public abstract 返回值类型 方法名();	//抽象方法，只声明而未实现
    }

工程规范提示：在一个.java文件中，只编写一个类，且类被public修饰。

实例代码：

(1) Demo.java

package com.java.demo;

public class Demo{
    public static void main(String[] args){
        Student s = new Student();
        s.say();
        Nurse n = new Nurse();
        n.say();
    }
}

(2) Person.java

package com.java.demo;
/**
 * 抽象类
 */
public abstract class Person{
    //可以有非抽象部分（能确定的一部分先实现）
    String name;
    int age;
    //抽象部分
    public abstract void say();	//抽象方法
}

(3) Student.java

package com.java.demo;

public class Student extends Person{
    //将抽象父类的say()方法重写，实现
    public void say(){
        System.out.println("我是学生，好好学习，天天向上。");
    }
}

(4) Nurse.java

package com.java.demo;

public class Nusr extends Person{
    //@，表示一个注解
    @Override	//重写的注解，(用于对重写的say()方法进行检查是否为被重写的方法，是，不报错；否，报错)
    public void say(){
        System.out.println("我是Nurse~~~");
    }
}

6.3 不能被实例化（注意）

在抽象类的使用中有几个原则：
    ·抽象类本身是不能直接进行实例化操作的，即：不能直接使用关键字new完成。
    ·一个抽象类必须被子类所继承，继承抽象类的子类（如果不是抽象类）则必须覆写（重写）抽象类中的全部抽象方法。

6.4 常见问题（注意）

1、抽象类能否使用final声明？
    不能，因为final修饰的类是不能被继承的，而抽象类必须有子类才有意义，所以不能。
2、抽象类能否有构造方法？
    能有构造方法，而且子类对象实例化的时候的流程与普通类的继承是一样的，都是要先调用父类中的构造方法
    （默认是无参的），之后再调用子类自己的构造方法。

实例代码：

//① Demo.java
public class Demo{
    public static void main(String[] args){
        /**
         * 创建对象构造器执行细节：
         *    在创建对象的同时，先执行Person父类Object中的无参构造方法,再执行Person类
         *    中的无参构造方法，最后再执行Student的构造方法。
         */
        Student s = new Student();
        s.say();					//调用Student类中重写的say()方法
    }
}

//② Person.java
public abstract class Person{
    public Person(){
        System.out.println("抽象无参构造方法执行了~");
    }
    public abstract void say();	//抽象方法
}

//③ Student.java
public class Student extends Person{
    //将抽象父类的say()方法重写，实现
    void say(){
        System.out.println("我是学生，好好学习，天天向上。");
    }
}

6.5 抽象类和普通类的区别

1、抽象类必须用public或protected修饰（如果为private修饰，那么子类则无法继承，也就无法实现
   其抽象方法）。默认缺省值为public
2、抽象类不可以使用new关键字创建对象，但是在子类创建对象时，抽象父类也会被JVM实例化。
3、如果一个子类继承抽象类，那么必须实现其所有的抽象方法。如果有未实现的抽象方法，那么子类也
   必须定义为abstract类。

7、接口（重点）

7.1 概念

如果一个类中的全部方法都是抽象方法，全部属性都是全局常量，那么此时就可以将这个类定义成一个接口。
定义格式：
    interface 接口名称{
    	全局常量;//public static final修饰
    	抽象方法;
	}

代码示例：

//① Demo.java
package com.java.demo;

public class Demo{
    public static void main(String[] args){
        Student s = new Student();
        s.say();
    }
}

//② Person.java
package com.java.demo;

public interface Person{
    public static final String SCHOOL = "阳光中学";	//全局常量
    public abstract void say();	//抽象方法
}

//③ Student.java
package com.java.demo;

public class Student implements Person{
    
    @Override
    public void say(){
        System.out.println("我就读于：" + SCHOOL); //我就读于：阳光中学
    }
}

7.2 面向接口编程思想

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

优点：
    1、降低程序的耦合性。
    2、易于程序的扩展。
    3、有利于程序的维护。

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

因为接口本身都是由全局常量和抽象方法组成，所以接口中的成员定义可以简写：
    1、全局常量编写时，可以省略public static final关键字，例如：
    	public static final String INFO = "内容";
		简写后：String INFO = "内容";

	2、抽象方法编写时，可以省略public abstract 关键字，例如：
        public abstract void print();
		简写后：void print();

7.4 接口的(实现)implements

接口借助类可以多实现：
格式：
    class 类 implements 父接口1,父接口2...{
        
    }

以上的代码称为接口的实现，那么如果一个类既要实现接口，又要继承抽象类（或非抽象类）的话，则按照以下的格式编写即可：
	class 子类 extends 父类 implements 父接口1,父接口2...{
        
    }

7.5 接口的继承（注意）

接口因为都是抽象部分，不存在具体的实现，所以允许多继承，例如：
    interface C extends A,B...{
    	
	}

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

3.7.6 接口与抽象类的区别（注意）

1、抽象类要被子类继承；接口要被类（或者子类）实现。
2、接口只能声明抽象方法；抽象类中既可以声明抽象方法，也可以声明非抽象方法。
3、接口里定义的变量只能是公共的静态的常量；抽象类中的变量是普通变量。
4、抽象类通过继承(extends)来使用，无法多继承；接口通过实现(implements)来使用
   ，可以多实现。接口也可以通过（extends）来使用，多继承更多接口。
5、抽象类中可以包含static方法，但是接口中不允许（静态方法不能被类（或者子类）重写，
   因此接口中不能声明静态方法）
6、接口不能有构造方法，但是抽象类可以有。

8、多态（重点）

8.1 概念

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

8.2 多态的体现

对象的多态性，从概念上非常好理解，在类中有子类和父类之分，对象多态性就从此而来。
    
PS：方法的重载 和 重写 也是多态的一种，不过是方法的多态（相同方法名的多种形态）。
    重载：一个类中方法的多态性体现。
    重写：子父类中方法的多态性体现。

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

类似于基本数据类型的转换：
    
·向上转型：将子类实例变为父类实例
    |-格式：父类 父类对象 = 子类实例;
·向下转型：将父类实例变为子类实例
    |-格式：子类 子类对象 = (子类)父类实例;

示例代码（多态的使用）：

(1) Demo.java

package com.java.demo;

public class Demo{
    public static void main(String[] args){
        Student a = new Student();
        Nurse b = new Nurse();
        
        Person p1 = a;	//向上转型
        Person p2 = b;	//向上转型
        
        Student a2 = (Student)p1;	//向下转型，P1是父类实例，经子类强制类型转换成为子类实例，赋给子类对象。
        a2.say();
        
        //Student a3 = (Student)p2;	//p2不能转型为Student，因p2不是学生，而是护士。
        //a3.say();
        
        /**
         * 多态的应用，向上转型，通过say()方法将Student（子类实例）转型为Person（父类实例）,赋给实例对象。
		 * 再通过父类对象调用父中的方法（p.say()）。
         */
        Student s = new Student();
        say(s);
    }
    //根据实际操作，抽象类可以声明一个对象，但不能new一个对象。可以向此对象传递一个子类对象的地址。接口同理。
    //这里say()方法的形参创建了一个抽象类的对象p，等待调用接收实参子类对象s的传来
    public static void say(Person p){
        p.say();
    }
}

(2) Person.java

package com.java.demo;
/**
 * 抽象类
 */
public abstract class Person{
    //可以有非抽象部分（能确定的一部分先实现）
    String name;
    int age;
    
    public void sing(){
        System.out.println(name + "，正在唱歌~~~");
    }
    
    //抽象部分（不确定的部分抽象）
    public abstract void say();	//抽象方法
}

(3) Student.java

package com.java.demo;

public class Student extends Person{
    //将抽象父类的say()方法重写，实现！
    public void say(){
        System.out.println("我是Student~~~");
    }
}

(4) Nurse.java

package com.java.demo;

public class Nurse extends Person{
    //@，表示一个注解
    @Override	//重写的注解，(用于对重写的say()方法进行检查是否为被重写的方法，是，不报错；否，报错)
    public void say(){
        System.out.println("我是Nurse~~~");
    }
}

9、instanceof（重点）

作用：
    判断某个对象或接口是否是指定类（或子类）的实例，则可使用instanceof关键字判断
    
格式：
    实例化对象 instanceof 类    //判断“实例化对象”是否为“类”的实例，是为true，否为false

以下引用于一位博主的解释：
instanceof 严格来说是Java中的一个双目运算符，用来测试一个对象是否为一个类的实例，用法为：
				boolean result = obj instanceof Class
　　其中 obj 为一个对象，Class 表示一个类或者一个接口，当 obj 为 Class 的对象，或者是其直接或
   间接子类，或者是其接口的实现类，结果result 都返回 true，否则返回false。

　　注意：编译器会检查 obj 是否能转换成右边的class类型，如果不能转换则直接报错，如果不能确定类型，
    	则通过编译，具体看运行时定。

示例代码（instanceof的使用）：

(1) Demo.java

package com.java.demo;

public class Demo{
    public static void main(String[] args){
        Nurse n = new Nurse();
        say(n);
    }
    public static void say(Person p){
        //如何判读传入的对象是此类型的那种形态(这里是Student)（哪个子类的对象(这里是Student的)）
        //这里p是Student的间接子类对象，因Student继承了Person，Person就拥有了其属性并重写实现其方法。
        if(p instanceof Student){
            Student s = (Student)p;
        	s.say();
        }else{
            System.out.println("必须传入学生形态，才可以执行~");
        }
    }
}

(2) Person.java

package com.java.demo;
/**
 * 抽象类
 */
public abstract class Person{
    //可以有非抽象部分（能确定的一部分先实现）
    String name;
    int age;
    //抽象部分
    public abstract void say();	//抽象方法
}

(3) Student.java

package com.java.demo;

public class Student extends Person{
    //将抽象父类的say()方法重写，实现
    void say(){
        System.out.println("我是学生，好好学习，天天向上。");
    }
}

(4) Nurse.java

package com.java.demo;

public class Nurse extends Person{
    //@，表示一个注解
    @Override	//重写的注解，(用于对重写的say()方法进行检查是否为被重写的方法，是，不报错；否，报错)
    public void say(){
        System.out.println("我是Nurse~~~");
    }
}

10、Object类（重点）

10.1 概念

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

例如我们定义一个类：
public class Person{
}

其实它被使用时 是这样的：
public class Person extends Object{
}

10.2 Object的多态

使用Object可以接收（任意）的数据类型。
	任意的数据类型是指：基本数据类型（变量有值） + 引用数据类型（对象被实例化）
    
通过new关键字在堆中开辟一段空间，并将地址赋给对象，此过程为对象的实例化。反之称为对象的创建，没有指定的空间。
    
	注意：在变量有值或对象有指向的空间时，才可以使用Object的类去接收。
正确示例:                        | 错误示例：
Object o;                       | Object o;
int a = 100;                    | int a;
//将a的值赋给o
o = a;                          | o = a;	 //(×，在java中不能引用未赋值的变量)
Random r = new Random();        | Scanner input;
//将r的地址赋给o（使o指向r所指向的内存空间）
o = r;                          | o = input; //(×，不能引用未实例化的对象)

10.3 toSting方法

建议重写Object中的toString方法。此方法的作用：返回对象的 字符串 表示形式。
    Object的toString方法，返回对象的内存地址
通过重写toString方法，可以更加灵活地实现我们想要得到的数据信息。

示例代码：

//① Demo.java
package com.java.demo;

public class Demo{
    public static void main(String[] args){
        Person p1 = new Person("小明",18);
        System.out.println(p1);	//自我介绍，姓名：小明，年龄：18岁了
        Person p2 = new Person("小李",20);
        System.out.println(p2);	//自我介绍，姓名：小李，年龄：20岁了
    }
}

//② Person.java
package com.java.demo;

public class Person{
    private String name;
    private int age;
    
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        this.age = age;
    }
    
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    public Person(){
        
    }
    
    public String toString(){
        return "自我介绍，姓名：" + this.name + "，年龄：" + this.age + "岁";
    }
}

10.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.quals(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。

示例代码：

//① Demo.java
package com.java.demo;

public class Demo{
    public static void main(String[] args){
        Person p1 = new Person("小明",18);
        Person p2 = new Person("小明",18);
        System.out.println(p1.getName() == p2.getName && p1.getAge() == p2.getAge());	//true
        //<==>
        System.out.println(p1.equals(p2));	//true
        
        String ss1 = new String("小李");
        String ss2 = new String("小李");
        System.out.println(ss1 == ss2);		//false
        System.out.println(ss1.equals(ss2));//true
        
        String s1 = "小刚";
        String s2 = "小刚";
        //因不通过new创建的字符串均在常量池中，且相同的字符串会被合成一个，
        //故：s1和s2指向同一个地址所存储的字符串。
        System.out.println(s1 == s2);	//true
    }
}
/**
 * 常量池在java用于保存在编译期已确定的，已编译的class文件中的一份数据。它包括了关于类，方法，
 * 接口等中的常量，也包括字符串常量，如String s = "java"这种申明方式；当然也可扩充，执行器
 * 产生的常量也会放入常量池，故认为常量池是JVM的一块特殊的内存空间。	——来源百度百科
 */

//② Person.java
package com.java.demo;

public class Person{
    private String name;
    private int age;
    
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        this.age = age;
    }
    
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    public Person(){
        
    }
    //equals()的使用
    public boolean equals(Object o){
        //当前对象的引用p1与传递过来的对象p2进行比较
        if(this == o){	//地址相同，说明指向同一块内存空间，其值就相同，返回true
            return true;
        }
        if(o == null){	//若传递过来的对象p2为空，返回false
            return false;
        }
        //若传递过来的对象p2为Person的类或子类，执行下一步操作；否则返回false
        if(o instanceof Person){
            Person p2 = (Person)o;	//向下转型赋给Person类型的p2对象
            //若当前对象p1的name与传递过来的对象p2的name的字符串相同，
            //且当前对象p1的age与传递过来的p2的age值相同，返回true；相反，返回false。
            if(this.name.equals(p2.name) && this.age == p2.age){
                return true;
            }else{
                return false;
            }
        }else{
            return false;
        }
    }
}
/**
 * 总结：
 *	  ①对于基本数据类型的比较用“==”。
 *	  ②对于引用数据类型的比较用equals()方法：
 *		  -String类型借助new创建的字符串，直接用equals()方法，因Sting.class中已定义好了。
 *		  -String类型未借助new创建的字符串，直接用“==”比较即可。
 *		  -自己定义的类，需要重写equals()方法。
 */

11、API的使用

具体，见JDK1.1API开发手册

12、内部类

概念

在java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。
    广泛意义上的内部类一般来说包括这四种：
    	1、成员内部类
    	2、局部内部类
    	3、匿名内部类
    	4、静态内部类

成员内部类

成员内部类是最普遍的内部类，它的定义为位于另一个类的内部，形如下面的形式：
    
class Outter{
    private double x = 0;
    
    public Outer(double x){
        this.x = x;
    }
    //成员内部类Inner
    class Inner{
        public void say(){
            System.out.println("x = " + x);
        }
    }
}

特点：成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）。
    不过要注意的是，当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认
    情况下访问的是成员内部类的成员。如果要访问外部类的同名成员，需要以下面的形式进行访问：
    	外部类.this.成员变量
    	外部类.this.成员方法

外部使用成员内部类
    Outter outter = new Outter();
	Outter.Inner inner = outter.new Inner();

局部内部类

示例代码1：

局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。
    
例如：
    class Person{
        public Person(){
        }
    }

	class Man{
        public Man(){
        }
        
        public People getPerson(){
            //局部内部类Student
            class Student extends People{
                int age = 0;
            }
            return new Student();
        }
    }

示例代码2：

package com.java.test;

public class Demo2{
    public static void main(String[] args){
        //局部内部类Person
        class Person{
            public void say(){
                System.out.println("局部内部类~");
            }
        }
        Person p = new Person();
        p.say();
    }
}

示例代码3（局部内部类的使用）：

//① Demo.java
package com.java.demo;

public class Demo{
    public static void main(String[] args){
        //局部内部类PersonImp
        class PersonImp implements Person{
            @Override
            public void say(){
                System.out.println("新编写的局部内部类的say方法内容");
            }
        }
        PersonImp p = new PersonImp();
        say(p);
    }
    
    public static void say(Person p){
        
    }
}

//② Person.java
package com.java.demo;

public interface Person{
    void say();
}

示例代码4（使用系统的某个API，来演示局部内部类的使用 <不用刻意地去记，理解即可；

​ 因为刻意的认真学习赶不上技术的快速变化>）：

//① Demo.java
package com.java.com;

import java.awt.Frame;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;

public class Demo{
    public static void main(String[] args){
        Frame f = new Frame("QQ登录器");
        f.setVisible(true);
        f.setSize(300,300);
        //局部内部类MyWindowListener
        class MyWindowListener implements WindowListener{
			@Override
			public void windowOpened(WindowEvent e) {
				
			}
            
			@Override
			public void windowClosing(WindowEvent e) {
				System.out.println("~~~");
				return;
			}

			@Override
			public void windowClosed(WindowEvent e) {
				
			}

			@Override
			public void windowIconified(WindowEvent e) {
				
			}

			@Override
			public void windowDeiconified(WindowEvent e) {
				
			}

			@Override
			public void windowActivated(WindowEvent e) {
				
			}

			@Override
			public void windowDeactivated(WindowEvent e) {
				
			}
            
        }
        MyWindowListener lis = new MyWindowListener();
        f.addWindowListener(lis);
    }
}

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

匿名内部类（只使用一次的类）

匿名内部类由于没有名字，所以它的创建方式有点奇怪。创建格式如下：
    
    new 父类构造器(参数列表) 或 实现接口()
	{
    	//匿名内部类的类体部分
	}

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

示例代码：

//① Demo.java
package com.java.demo;

public class Demo{
    public static void main(String[] args){
                   //匿名内部类
        Person p = new Person(){
            public void say(){
                System.out.println("匿名内部类执行了~~~");
            }
        };	//创建匿名内部类
        haha(p);
    }
    
    public static void haha(Person p){
        p.say();	//调用say()方法，打印输出：匿名内部类~~~
    }
}

//② Person.java
package com.java.demo;

public interface Person{
    void say();
}

注意：

在使用匿名内部类的过程中，我们需要注意如下几点：
    1、使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是两者不可兼得，
       同时也只能继承一个类或者实现一个接口。
    2、匿名内部类中是不能定义构造函数的。
    3、匿名内部类中不能存在任何的静态成员变量和静态方法。
    4、匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。
    5、匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。
    6、只能访问final型的局部变量（final关键字可省略）。

示例代码（局部内部类使用final参数）：

package com.java.demo;

public class Demo{
    public static void main(String[] args){
        /**
         * 面试：为什么要加final关键字？
         *		因为我们的内部类会被单独地编译成一个字节码文件，为了保证这个单独的文件中
         *		用到的备份变量a与外面的变量a值绝对一致，那么系统从规则上限制了这个值不可更改。
         */
        int a = 10;	//简写版，《==》final int a = 10;
        //a = 20;
        class PersonImp implements Person{
            @Override
            public void say(){
                System.out.println("新编写的局部内部类的say方法内容" + a);
            }
        }
        PersonImp p = new PersonImp();
        fun(p);
    }
    
    public static void fun(Person p){
    }
}

静态内部类

静态内部类也是定义在另一个类里面的类，仅在类的前面多了一个关键字static。
	静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似，并且它不能使用外部类的
	非static成员变量或者方法，这点很好理解，因为在没有外部类的对象的情况下，可以创建静态内
	部类的对象，如果允许访问外部类的非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(){
            
        }
    }
}

代码示例（静态内部类）：

//① Demo.java
package com.java.demo;

public class Demo{
    public static void main(String[] args){
        Book.Info info = new Book.Info();
        info.say();
    }
}

//② Book.java
package com.java.demo;

public class Book{
    private static String name;
    
    static class Info{
        public void say(){
            System.out.println("这是一个信息类~" + name);
        }
    }
}

13、包装类（重要）

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

序号	基本数据类型	取值范围	包装类	默认值
1	int	<==>	Integer	null
2	char	<==>	Character	null
3	float	<==>	Float	null
4	double	<==>	Double	null
5	boolean	<==>	Boolean	null
6	byte	<==>	Byte	null
7	short	<==>	Short	null
8	long	<==>	Long	null

以上的八种包装类，可以将基本数据类型按照类的形式进行操作。
    但是，以上的八种包装类也是分为两种大的类型的：
    	·Number：Integer、Short、Long、Double、Float、Byte都是Number的子类表示是一个数字。
    	·Object：Character、Boolean都是Object的直接子类。

装箱和拆箱操作

以下以Integer和Float为例进行操作
    
	将一个基本数据类型变为包装类，那么这样的操作称为装箱操作。
	将一个包装类变为一个基本数据类型，这样的操作称为拆箱操作。
    
因为所有的数值型的包装类都是Number的子类，Nueber的类中定义了如下的操作方法，以下的全部方法都是进行拆箱的操作。

序号	方法	描述（将包装类 拆箱 变成基本数据类型）
1	public byte byteValue()	用于Byte->byte
2	public abstract double doubleValue()	用于Double->double
3	public abstract float floatValue()	用于Float->float
4	public abstract int intValue()	用于Integer->int
5	public abstract long longValue()	用于Long->long
6	public abstract short shortValue()	用于Short->short

装箱与拆箱的操作：

在JDK1.4之前，如果要想装箱，直接使用各个包装类的构造方法即可，例如：
    int temp = 10;	//基本数据类型
	Integer x = new Integer(temp);	//将基本数据类型变为包装类（装箱）
	int temp = x.intValue();		//将包装类变为基本数据类（拆箱）

在JDK1.5，java新增了自动装箱和自动拆箱，而且可以直接通过包装类进行四则运算和自增自减操作。例如：
    Float f = 10.3f;	//自动装箱
	float x = f;		//自动拆箱
	System.out.println(f * f);	//直接利用包装类完成
	System.out.println(x * x);	//直接利用包装类完成

提示：

​ Integer i = new Integer(200); //这里的杠，代表是已过时的操作。（因在JDK1.5新增了

​ 自动装箱和自动拆箱功能）<这是Java更新的原因，每年更新两版，也会过时一些类>

​ 应改为：Integer i = 200;

示例代码：

package test.java.demo;

public class Demo{
    public static void main(String[] args){
        
        //手动装箱,JDK1.5之前
        Integer i = new Integer(200);
        //手动拆箱，JDK1.5之前
        int a = i.intValue();
        System.out.println(a);
        
        //自动装箱，JDK1.5开始
        Integer j = 200;
        //自动拆箱，JDK1.5开始
        int b = j;
    }
}
// 建议：以后采用 自动装箱 和 自动拆箱 的方式。

字符串转换（以下是将输入的字符串转成指定的数据类型）

使用包装类还有一个很优秀的地方在于：可以将一个字符串变为指定的基本数据类型，此点一般在接收输入数据上使用较多。
在Integer类中提供了以下的操作方法：
    public static int parseInt(String s)：将String变为int型数据。
    eg：
    	String I = new Scanner(System.in).nextLine();	//输入一个整数
        int i = Integer.parseInt(I);
在Float类中提供了以下的操作方法：
    public static float parseFloat(String s)：将String变成float型数据。
    eg：
    	String F = new Scanner(System.in).nextLine();	//输入一个小数
        float f = Float.parseFloat(F);
在Boolean类中提供了以下的操作方法：
    public static boolean parseBoolean(String s)：将String变为boolean
    eg：
    	String B = new Scanner(System.in).nextLine();	//输入一个boolean值
        boolean b = Boolean.parseBoolean(B);
    ....

14、可变参数

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

语法：
    权限修饰符 返回值类型 方法名称(数据类型... 参数名称){
    	//参数在方法内部，以数组的形式来接收
	}

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

示例代码：

package test.java.demo;

public class Demo{
    /**
     * 可变参数
     * @param args
     */
    public static void main(String[] args){
        System.out.println(sum());				//0
        System.out.println(sum(1));				//1
        System.out.println(sum(1,2,3));			//6
        System.out.println(sum(1,2,3,4,5));		//15
        System.out.println(sum(1,2,3,4,5,6,7));	//28
    }
    
    /**
     * 注意：可变参数只能出现在参数列表的最后！！！
     */
    /*
    	public static void haha(int... y,String x){	//Error!!!
        	
    	}
    */
    //改写后
    public static void haha(String x,int... y){		//Right(√)
        
    }
    /**
     * int...nums：表示的是可变参数，调用时可以传递0~n个整数
     * 在方法的内部，可变参数以数组作为载体体现
     * @param nums
     * @return
     */
    public static int sum(int... nums){
        int sum = num[0];
        for(int i = 1;i < nums.length;i++){
            sum += nums[i];
        }
        
        return sum;
    }
}

15、递归（不常用）

 /**
 * 1.递归是指方法的定义使用方法自身，是一种直接或间接调用自身方法的算法。
 * 2.递归调用的执行过程分为两个阶段：
 *		->递推阶段：从原问题出发,按递归公式递推从未知到已知,最终达到递归的条件。
 *
 *		->回归阶段：按递归的终止条件求出结果,逆向逐步代入递归公式,回归到原问题求解。
 *
 * 总结：整个递归解决条件 = 递归公式(规律) + 终止条件(递归的出口)
 */
    缺陷：占用内存大，且效率低。建议不使用，一旦超过栈内存整个程序将崩溃（一般栈内存很小不到2M）。
递归流程如下图所示：

示例代码：

package test.java.demo;

public class Demo{
    public static void main(String[] args){
        //阶乘
        int factValue = fact(5);	//求5!
        System.out.println(factValue);
    }
    public static int fact(int n){
        if(n == 1){
            return 1;
        }else{
            return n*fact(n-1);
        }
    }
}

示例代码图解：