JAVA-7-形参及返回值、权限及内容修饰符、内部类（重点是匿名内部类）

一：形式参数问题
　　形参数据类型可以是：
　　　　①基本类型：byte,short,int,long,float,double,char,boolean
　　　　②引用类型：类,接口,数组

　　形式参数如果是：
　　　　①基本类型：要的是该基本类型的数据值。
　　　　②引用类型：要的是该引用类型的对象。
　　　　　　A:数组　　　要的是该数据类型数组的对象。(地址值)
　　　　　　B:类　　　　要的是该类或者其子类的对象。(地址值)
　　　　　　C:抽象类　　要的是该抽象类的子类对象。(地址值)
　　　　　　D:接口　　　要的是该接口的实现类对象。(地址值)

二：返回值问题
　　返回值类型可以是：
　　　　①基本类型：byte,short,int,long,float,double,char,boolean
　　　　②引用类型：类，接口，数组

　　返回值类型是基本类型时：
　　　　返回的是该基本类型的数据值。
　　返回值类型是引用类型时：
　　　　①返回值是类名：其实返回的是该类对象或者其子类对象。(地址值)
　　　　②返回值是抽象类名：要的是该抽象类的子类对象。(地址值)
　　　　③返回值是接口名：要的是该接口的实现类对象。(地址值)

三：权限修饰符
　　权限修饰符：在哪种情况下可以被访问到。

四：常见的内容修饰
　　1:常见的修饰
　　　　类：public
　　　　　　public class HelloWorld {}
　　　　成员变量：private
　　　　　　private String name;
　　　　　　private int age;
　　　　构造方法：public
　　　　　　public Student() {}
　　　　　　public Student(String name,int age) {}
　　　　成员方法：public
　　　　　　public void show() {}
　　　　　　public void eat() {}
　　2:哪些东西可以修饰哪些东西
　　
　　　　注意：四种权限修饰符，只能有一种存在。
　　　　　　常见的组合：
　　　　　　　　类：
　　　　　　　　　　public class HelloWorld {}
　　　　　　　　　　public final class HelloWorld {}
　　　　　　　　　　public abstract class HelloWorld {}
　　　　　　　　成员变量：
　　　　　　　　　　private String name;
　　　　　　　　　　public final int X = 10;
　　　　　　　　　　public static int y = 20;
　　　　　　　　　　public static final int X = 30;
　　　　　　　　成员方法：
　　　　　　　　　　public void show(){}
　　　　　　　　　　public abstract void show();
　　　　　　　　　　public final void show(){}
　　　　　　　　　　public static void show() {}
　　　　　　　　　　public static final void show() {}

五：内部类
5.1内部类：把类A定义在类B的内部，类A就被称为内部类。
　　访问特点：
　　　　A:内部类可以直接访问外部类的成员，包括私有。
　　　　B:外部类要访问内部类的成员，必须创建对象。
5.2内部类分类：
　　成员位置：成员内部类
　　局部位置：局部内部类
　　
　　5.2.1
　　　　成员内部类：
　　　　　　外界如何创建对象？
　　　　　　　　外部类名.内部类名 对象名 = 外部类对象.内部类对象;
　　5.2.2内部类的关键词限定：
　　　　内部类举例：Body,Heart

//A:private 为了我们访问数据的安全性
        class Body {
            private class Heart {
                public void operator() {
                    System.out.println("给心脏做搭桥手术");
                }           
            }

            public void method() {
                if(你是医生吗?) {
                    Heart h = new Heart();
                    h.operator();
                }
            }
        }

　　直接访问：
　　　　Body.Heart bh = new Body().new Heart();
　　　　bh.operator();
　　为了身体的安全，外界是不能让他们直接创建对象。通过private进行修饰。这个时候就可以这样来使用：
　　　　Body b = new Body();
　　　　b.method();

//B:static  为了我们访问数据的方便性
        class Outer {
        public static class Inner {
            public void show() {
                System.out.println("show");
            }

            public static void show2() {
                System.out.println("show2");
            }
        }
    }

    class InnerClassDemo3 {
        public static void main(String[] args) {
            // 限定的新静态类
            //Outer.Inner oi = new Outer().new Inner();
            //格式：
            Outer.Inner oi = new Outer.Inner();
            oi.show();
            oi.show2();

            //Outer.Inner.show();
            Outer.Inner.show2();
        }
    }

5.2.３

　　/*
    需求：请补齐代码，在控制台输出30,20,10
    */
    class Outer {
        public int num = 10;

        private class Inner {
            public int num = 20;
            public void show() {
                int num = 30;
                System.out.println(？);//num
                System.out.println(？);//this.num
                System.out.println(？);//new Outer().num或者Outer.this.num
            }
        }

        public void method() {
            Inner i = new Inner();
            i.show();
        }
    }

    class InnerClassTest {
        public static void main(String[] args) {
            Outer o = new Outer();
            o.method();
        }
    }

5.3局部内部类：
　　A:可以直接访问外部类的成员，包括私有
　　B:在成员方法中创建局部内部类的对象，调用局部内部类的功能
　　
　　面试题：为什么局部内部类访问局部变量必须加final修饰呢?
　　　　因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。为了让数据还能继续被使用，就用fianl修饰，这样，在堆内存里面存储的其实是一个常量值。

5.4匿名内部类（重中之重）
　　没有名字的局部内部类,就是内部类的简化写法

　　前提：
　　　　存在一个类或者接口，这里的类可以是具体类也可以是抽象类。

　　格式：
　　　　new 类名或者接口名() {
　　　　　　重写方法;
　　　　};

　　本质：是一个继承了类或者实现了接口的子类匿名对象。

5.5面试题

　　/**
    按照要求，补齐代码
        interface Inter { void show(); }
        class Outer { //补齐代码 }
        class InnerClassTest {
            public static void main(String[] args) {
                  Outer.method().show();
              }
        }
    要求在控制台输出”HelloWorld”
    */


//答案如下：
package com.edu;
//要求在控制台输出“HelloWorld”
interface Inter { 
　　void show(); 
}

class Outer { 
    //补齐代码 
    //创建method()是静态的
    public static Inter method(){
        return new Inter(){
            @Override
            public void show() {
                System.out.println("HelloWorld");
            }};
    }
}

class InnerClassTest {
    public static void main(String[] args) {
          Outer.method().show();
          /**
           * 1.method()这个方法如果可以直接通过类名实现调用的话，说明这个方法是static
           * 2.Outer.method()可以紧接着调用show()
           * 说明method方法的返回值一定是一个Inter接口的实现类对象
           * 3.所以这个实现类对象我们可以直接使用匿名内部类的形式去进行实现，
           * 因为匿名内部类的本质就是实现了Inter接口的一个实现类匿名对象
           */
      }
}