第七天笔记总结

Posted 2020-09-11

一：形式参数问题
    数据类型：
        基本类型：byte,short,int,long,float,double,char,boolean
        引用类型：类,接口,数组
 
    形式参数：
        基本类型：要的是该基本类型的数据值。
        引用类型：要的是该引用类型的对象。
            A:数组 要的是该数据类型数组的对象。(地址值)
            B:类   要的是该类或者其子类的对象。(地址值)
            C:抽象类    要的是该抽象类的子类对象。(地址值)
            D:接口  要的是该接口的实现类对象。(地址值)
 
 
二：返回值问题
    返回值：
        基本类型：byte,short,int,long,float,double,char,boolean
        引用类型：类，接口，数组
 
    返回值之基本类型：
        基本类型：返回的是该基本类型的数据值。
        案例：创建一个加法的方法，返回值就是基本类型的具体的指
   
    返回值之引用类型：
    返回值是类名：其实返回的是该类对象或者其子类对象。(地址值)
    返回值是抽象类名：要的是该抽象类的子类对象。(地址值)
    返回值是接口名：要的是该接口的实现类对象。(地址值)
       
   
三：权限修饰符（代码进行测试）
    权限修饰符：在哪种情况下可以被访问到。
                            本类        同一个包下的类    不同包下的子类        不同包下的无关类
        private             yes             no                  no                      no
        默认(什么都不写)    yes             yes                 no                      no
        protected           yes             yes                 no                      no
        public              yes             yes                 yes                     yes
 
 
四：常见的内容修饰
1:常见的修饰
       
    类：public
        publicclass HelloWorld {}
 
    成员变量：private
        privateString name;
        privateint age;
 
    构造方法：public
        publicStudent() {}
        publicStudent(String name,int age) {}
 
    成员方法：public
        publicvoid show() {}
        publicvoid eat() {}
 
2:哪些东西可以修饰哪些东西
                类  成员变量    构造方法    成员方法
    private         Y               Y       Y
    默认        Y   Y              Y       Y
    protected       Y               Y       Y
    public      Y   Y               Y       Y
    static          Y                       Y
    final       Y   Y                       Y
    abstract    Y                           Y
 
    注意：
        四种权限修饰符，只能有一种存在。
 
        classDemo {}
 
    常见的组合：
        类：
            publicclass HelloWorld {}
            publicfinal class HelloWorld {}
            publicabstract class HelloWorld {}
 
        成员变量：
            privateString name;
            publicfinal int X = 10;
            publicstatic int y = 20;
            publicstatic final int X = 30;
       
        成员方法：
            publicvoid show(){}
            publicabstract void show();
            publicfinal void show(){}
            publicstatic void show() {}
            publicstatic final void show() {}
           
           
五：内部类
    5.1
    内部类：
        把类A定义在类B的内部，类A就被称为内部类。
 
    访问特点：（代码验证只要编译通过说明就是没有问题的）
        A:内部类可以直接访问外部类的成员，包括私有。
        B:外部类要访问内部类的成员，必须创建对象。
 
    5.2
    内部类分类：
        成员位置：成员内部类
        局部位置：局部内部类
   
    5.2.1
    成员内部类：
        外界如何创建对象
 
        外部类名.内部类名对象名 = 外部类对象.内部类对象;
 
    5.2.2
    内部类的关键词限定：
        内部类举例：
        Body,Heart
        //A:private为了我们访问数据的安全性
        classBody {
            privateclass Heart {
                publicvoid operator() {
                    System.out.println("给心脏搭个桥");
                }          
            }
 
            publicvoid method() {
                if(你是医生吗?){
                    Hearth = new Heart();
                    h.operator();
                }
            }
        }
 
    直接访问：
        Body.Heartbh = new Body().new Heart();
        bh.operator();
 
    为了身体的安全，外界是不能让他们直接创建对象。通过private进行修饰。
    这个时候就可以这样来使用：
        Body b =new Body();
        b.method();
 
    成员内部类的修饰：
        A:private为了我们访问数据的安全性
        B:static  为了我们访问数据的方便性
   
   
    5.2.3
    //B:static  为了我们访问数据的方便性
        classOuter {
 
        publicstatic class Inner {
            publicvoid show() {
                System.out.println("show");
            }
 
            publicstatic void show2() {
                System.out.println("show2");
            }
        }
 
    }
 
    classInnerClassDemo3 {
        publicstatic void main(String[] args) {
            // 限定的新静态类
            //Outer.Inneroi = new Outer().new Inner();
            //格式：
            Outer.Inneroi = new Outer.Inner();
            oi.show();
            oi.show2();
 
            //Outer.Inner.show();
            Outer.Inner.show2();
        }
    }
   
   
    5.2.4
    面试题：
    /*
    需求：请补齐代码，在控制台输出30,20,10
    */
    class Outer {
        publicint num = 10;
 
        privateclass Inner {
            publicint num = 20;
            publicvoid show() {
                intnum = 30;
                System.out.println(？);//num
                System.out.println(？);//this.num
                System.out.println(？);//newOuter().num或者Outer.this.num
            }
        }
 
        publicvoid method() {
            Inneri = new Inner();
            i.show();
        }
    }
 
    classInnerClassTest {
        publicstatic void main(String[] args) {
            Outero = new Outer();
            o.method();
        }
    }
 
   
    5.3
    局部内部类：
    A:可以直接访问外部类的成员，包括私有
    B:在成员方法中创建局部内部类的对象，调用局部内部类的功能
 
    面试题：
        从内部类中访问本地变量number; 需要被声明为最终类型?
 
        为什么：局部内部类访问局部变量必须加final修饰呢?
            因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。
            为了让数据还能继续被使用，就用fianl修饰，这样，在堆内存里面存储的其实是一个常量值。
   
    5.4
    匿名内部类
        没有名字的局部内部类,就是内部类的简化写法
 
    前提：
        存在一个类或者接口
        这里的类可以是具体类也可以是抽象类。
 
    格式：
        new 类名或者接口名() {
            重写方法;
        };
 
    本质：
        是一个继承了类或者实现了接口的子类匿名对象。
       
    5.5
    匿名内部类在开发中的实际应用。
    案例演示：传入的方法的参数是一个接口（方式一：定义一个已经实现了接口的类  方式二：匿名内部类的方式）
       
   
    5.6面试题
    /*
    按照要求，补齐代码
        interfaceInter { void show(); }
        classOuter { //补齐代码 }
        classInnerClassTest {
            publicstatic void main(String[] args) {
                  Outer.method().show();
              }
        }
    要求在控制台输出”HelloWorld”
    */
    答案：
    interfaceInter {
        voidshow();
    }
 
    class Outer {
        //补齐代码
    }
 
    classInnerClassTest {
        publicstatic void main(String[] args) {
              Outer.method().show();
        }
    }