内部类引入

形式参数问题

研究的引用数据类型:数组,类,接口
		public void show(int[] arr){}  //如果数组,需要有一个数组对象
		public viod show(具体类型 变量名){//调用方法,实际参数需要创建当前这个类的对象
            使用这个变量名
		}
		public void show(抽象类型 变量名){//调用方法,实际参数需要传递当前抽象类的子类对象
            ///
		}
		public void show(接口类型 变量名){//调用方法,实际参数需要传递的是当前接口的子实现类对象!
            //
		}
		

返回值问题

研究的时候引用类型:数组,类,接口
		public int[] method(int[] arr) { //返回是数组类型,需要返回数组对象
            
            //完成了各种排序
            return 数组对象;
		}
		
		public 具体类  method(){//返回值是具体类型,需要返回的是当前具体类的对象!
            
            //?
            //1)创建具体类对象
            //return 对象名;
            
            //2)直接使用匿名对象
            return new 类名() ;
		}
		
		public 抽象类 method(){//返回值是抽象类型,需要返回的是该抽象类的子类对象!
            
            //抽象不能实例化
            抽象类 对象名 = new 子类名() ; //抽象类多态
            return 对象名;
            
            //return new 子类名() ;
		}
		
		
		
		public 接口 method(){//返回值是接口类型,需要返回的是当前接口的子实现类对象!
            
            //接口不能实例化
            
            //接口多态
            接口名 对象名 = new 子实现类名() ;
            return 对象名 ;
            
            //return new 接口子实现类名();
		}

1.内部类(了解的格式)

分类有哪些

成员内部类:类中,方法外

			特点:可以访问外部类成员(包括私有成员)
			直接去访问外部类的中的成员内部类的成员方法:(成员内部类没有privata和static修饰)
									外部类名.内部类名 对象名 = new 外部类名().内部类名();

//外部类
class Outer2{
    //成员变量
    public   int num = 20 ;
    private  int num2 = 50 ;
    //成员内部类
    class Inner2{
        //成员方法
        public void show(){
            System.out.println(num) ;
            System.out.println(num2) ;
        }
    }

    //外部类的成员方法
    public void method(){
       // show() ; Outer2自己的show方法
       //访问成员内部类的成员方法
       //创建Inner2类对象
       Inner2 in = new Inner2() ;
       in.show() ;
    }
}

//测试类
public class InnerClassDemo2 {
    public static void main(String[] args) {

        //创建外部类对象
        //访问外部类的成员方法,间接的调用了成员内部类的成员方法
        Outer2 ou = new Outer2() ;
        ou.method() ;
        System.out.println("--------------------------------------------------") ;
        //测试类中:想直接去访问外部类里面的成员内部类的show
        //外部类.内部类名 对象名 = new 外部类名().new 内部类名() ;
        Outer2.Inner2 oi = new Outer2().new Inner2() ;
        oi.show() ;
    }
}

局部内部类:在方法定义中定义的类

	特点:可以访问外部类成员(包括私有成员)
		内部类的成员安全,加入private,
		成员内部类可以使用过static修饰
				使用static修饰的特点:
					静态成员内部类里面的所有成员方法,访问外部类成员必须先为静态
					
					直接访问静态的成员内部类的成员方法:
						外部类名.内部类名 对象名 = new 外部类名.内部类名();

package com.qf.innerclass_01;

/**
 * 成员内部类所涉及到的修饰符的问题:
 *      有的时候不想让外部类直接去访问内部类的成员,为了保证内部类的成员安全,加入private
 *    举例:
 *          人有身体,身体有心脏;
 *       伪代码
 *          class Body{
 *                  //身体内有心脏
 *                  //为了保证安全性,加入private修饰
 *                 private class Heart{
 *                   //成员方法
 *                    public void operator(){
 *                            System.out.println("心脏搭桥") ;
 *                    }
 *                 }
 *
 *                 //外部类的成员方法
 *                 public void method(){
 *                     if(你是外科医生){
 *                         //创建Heart对象,去调用operator方法
 *                     }
 *                 }
 *
 *
 *          }
 *
 *
 *     //直接访问成员内部类中的operator方法
 *     外部类名.内部类名 对象名 = new 外部类名().new 内部类名() ;
 *     Body.Heart bh = new Body().new Heart() ;会报错的
 *
 *
 *    成员内部类可以使用过static修饰:
 *    特点:静态的成员内部类它里面的所有 成员方法:
 *          无论是静态的方法还是非静态的,访问外部类的成员:必须先为静态
 *
 *     想直接去访问静态的成员内部类的这些成员方法:??
 *
 *     外部类名.内部类名 对象名 = new 外部类名.内部类名();
 *
 */
//外部类
class Outer3{
    private int num = 100;
    public static int num2 = 20 ;
    //静态修饰
    static class Inner3{  //Inner3现在看成是外部类的静态成员!
            //非静态的方法
        public void show(){
          //  System.out.println(num) ;
            System.out.println(num2) ;
            System.out.println("show Inner3");
        }

        //静态的方法
        public static void show2(){
            System.out.println(num2) ;
            //System.out.println(num) ;
            System.out.println("show2 Inner3");
        }
    }
}

//测试类
public class InnerClassDemo3 {
    public static void main(String[] args) {

        //访问成员内部类的成员方法
        //外部类名.内部类名 对象名 = new 外部类().new 内部类名() ;
        //Outer3.Inner3 oi = new Outer3().new Inner3() ; 用不了,只能针对非静态的成员内部类!

        //针对静态的成员内部类:直接去访问里面的成员方法
        //外部类名.内部类名 对象名 = new 外部类名.内部类名();
        Outer3.Inner3 oi = new Outer3.Inner3() ;//Inner3类看成是Outer3的静态成员
        oi.show() ;
        oi.show2() ;

        System.out.println("----------------------------------------");
        //show2()是静态的成员内部类的静态成员
        Outer3.Inner3.show2();
    }
}

面试题:

控制台打印 30 20 10

class Outer2{
    int num = 10 ;
    //成员内部类
    class Inner2{
        int num = 20 ;
        public void show(){
            int num = 30 ;
            //补全代码
            System.out.println(num) ; //就近原则
            System.out.println(this.num) ; //访问本类的成员变量
           // System.out.println(new Outer2().num) ; //创建外部类对象.变量名
            //this:代表当前类---->Outer2.this--->外部类的this限定(访问的是外部类中的信息)
            System.out.println(Outer2.this.num);
        }
    }
}
//测试类
public class InnerClassDemo2 {
    public static void main(String[] args) {
        Outer2.Inner2 oi = new Outer2().new Inner2() ;
        oi.show();
    }
}

局部内部类里面的成员在访问局部变量的时候,局部变量有什么要求?

局部内部类里面的成员在访问局部变量的时候,局部变量有什么要求?
JDK8以前的版本,局部内部类在访问外部类的成员方法中的局部变量的时候,此时局部变量必须加入final修饰!
原因:
			局部变量的生命周期随着方法调用而存在,随着方法调用结束而消失;
		外部类的成员方法调用完毕,此时这个局部变量应该释放了,但是当前这个成员方法中创建局部内部类对象
		使用局部内部类对象访问它里面的成员方法,成员方法还在使用这个局部变量,所以此时这个变量为常量,显示的加入final修饰
		JDK8以及jdk8以后:优化了
		可以通过反编译工具---->自动加入final,还是定义一个常量

2.内部类的一种简写:针对接口/抽象类:匿名内部类(重点)

匿名内部类:是内部类的一种简化格式
	针对抽象类或者接口去使用
		匿名的格式
			new 类名/接口名(){
				重写方法;
			};
			应用范围:在局部位置中使用
			匿名内部类的本质:
					是继承该抽象类或者实现接口的子类对象

//定义接口
interface Inter{
    void show() ;
    void show2() ;
}
//正常有一个接口的实现类
/*class InterImpl implements Inter{ //有名字的子实现类

    @Override
    public void show() {
        System.out.println("show Inter...");
    }
}
    //在测试类中测试子实现类
        Inter inter = new InterImpl() ;
        inter.show();

*/
//Outer类
class Outer{
    //外部类的成员方法
    public void method(){
        /**
         * new 类名(抽象类)或者接口名(){
         *                重写类里面或者接口的抽象功能!
         *            } ;
         */
      /*  new Inter(){

            @Override
            public void show() {
                System.out.println("show Inter...");
            }

            @Override
            public void show2() {
                System.out.println("show2 Inter....");
            }
        }.show();  //调用接口的方法

        new Inter(){

            @Override
            public void show() {
                System.out.println("show Inter...");
            }

            @Override
            public void show2() {
                System.out.println("show2 Inter....");
            }
        }.show2();*/

        //优化:给匿名内部类----起一个名字,使用对象名来访问
        Inter inter = new Inter() {
            @Override
            public void show() {
                System.out.println("show Inter");
            }

            @Override
            public void show2() {
                System.out.println("show2 Inter");
            }
        } ;

        inter.show();
        inter.show2();
    }
}
//测试类
public class InnerClassDemo {
    public static void main(String[] args) {
        Outer outer = new Outer() ;
        outer.method() ;

    }
}

package com.qf.return_05;

/**
 * 匿名内部类开发中使用场景2:
 *  方法返回值是抽象类或者接口
 */
interface Love{
    void love() ;
}
//LoveDemo
class LoveDemo{
    public Love method(){ //返回是一个接口:返回接口的子实现类对象
        //?如何返回
        //接口不能new
        //接口多态
        //Love l = new LoveImpl() ;
        //return  l;

        //return  new LoveImpl() ;

        //2使用接口的匿名内部类
        /**
         * new 类名或者接口(){
         *     //重写方法
         * }
         */
        return  new Love() {
            @Override
            public void love() {
                System.out.println("爱生活,爱Java,爱高圆圆!");
            }
        };
    }
}
//定义一个子实现类
class LoveImpl implements  Love{

    @Override
    public void love() {
        System.out.println("love life,love 高圆圆");
    }
}


//测试类
public class ReturnDemo {
    public static void main(String[] args) {
        LoveDemo ld  = new LoveDemo() ;
        Love love = ld.method(); //使用的接口匿名内部类的子实现类对象!
        love.love();
    }
}