重踏学习Java路上_Day10(形参与返回值，包，修饰符，内部类)

1:形式参数和返回值的问题(理解)
    (1)形式参数：
         类名：需要该类的对象，总之需要类变量的都是需要其实例化的对象      特别例子：//匿名对象用法 new StudentDemo().method(new Student());//
        

　　　抽象类名：需要该类的子类对象，抽象类本身不能实例化，抽象类有构造方法，但不能用作实例化调用，仅仅用于子类访问父类数据的初始化，继承父类的子类方式有两种（1.抽象类继承抽象类，此时不能实例化，但也不用重写抽象方法；2.具体类继承抽象类，重写抽象方法，使其能进行实例化，使其在堆内存区有一份对象数据，把引用地址赋值给抽象类的引用类型变量完成实例化）
        

 　　　接口名：需要该接口的实现类对象，接口本身不能实例化，因为没有构造方法，实现接口的子类方式有两种（1.抽象类实现接口，此时不能实例化，但也不用重写抽象方法；2.具体类实现对象，重写接口抽象方法，使其能进行实例化，使其在堆内存区有一份对象数据，把引用地址赋值给接口的引用类型变量完成实例化）

例子：

类作为形式参数：

class Student {
    public void study() {
        System.out.println("Good Good Study,Day Day Up");
    }
}

class StudentDemo {
    public void method(Student s) { //ss; ss = new Student();  Student s = new Student();
        s.study();
    }
}

class StudentTest {
    public static void main(String[] args) {
        //需求：我要测试Student类的study()方法
        Student s = new Student();
        s.study();
        System.out.println("----------------");
        
        //需求2：我要测试StudentDemo类中的method()方法
        StudentDemo sd = new StudentDemo();
        Student ss = new Student();
        sd.method(ss);
        System.out.println("----------------");
        
        //匿名对象用法
        new StudentDemo().method(new Student());
    }
}

抽象类作为形式参数：

abstract class Person {
    public abstract void study();
}

class PersonDemo {
    public void method(Person p) {//p; p = new Student();  Person p = new Student(); //多态
        p.study();
    }
}

//定义一个具体的学生类
class Student extends Person {
    public void study() {
        System.out.println("Good Good Study,Day Day Up");
    }
}

class PersonTest {
    public static void main(String[] args) {
        //目前是没有办法的使用的
        //因为抽象类没有对应的具体类
        //那么，我们就应该先定义一个具体类
        //需求：我要使用PersonDemo类中的method()方法
        PersonDemo pd = new PersonDemo();
        Person p = new Student();
        pd.method(p);
    }
}

接口作为形式参数：

interface Love {
    public abstract void love();
}

class LoveDemo {
    public void method(Love l) { //l; l = new Teacher();  Love l = new Teacher(); 多态
        l.love();
    }
}

//定义具体类实现接口
class Teacher implements Love {
    public void love() {
        System.out.println("老师爱学生,爱Java,爱林青霞");
    }
}

class TeacherTest {
    public static void main(String[] args) {
        //需求：我要测试LoveDemo类中的love()方法
        LoveDemo ld = new LoveDemo();
        Love l = new Teacher();
        ld.method(l);
    }
}

    (2)返回值类型：
        类名：返回的是该类的对象
        抽象类名：返回的是该类的子类对象
        接口名：返回的是该接口的实现类的对象

类，抽象类，接口作为返回值的例子：

类做返回：

class Student {
    public void study() {
        System.out.println("Good Good Study,Day Day Up");
    }
}

class StudentDemo {
    public Student getStudent() {
        //Student s = new Student();
        //Student ss = s;
        
        //Student s = new Student();
        //return s;
        return new Student();
    }
}

class StudentTest2 {
    public static void main(String[] args) {
        //需求：我要使用Student类中的study()方法
        //但是，这一次我的要求是，不要直接创建Student的对象
        //让你使用StudentDemo帮你创建对象
        StudentDemo sd = new StudentDemo();
        Student s = sd.getStudent(); //new Student(); Student s = new Student();
        s.study();
    }
}

抽象类做返回：

abstract class Person {
    public abstract void study();
}

class PersonDemo {
    public Person getPerson() {
        //Person p = new Student();
        //return p;
        
        return new Student();
    }
}

class Student extends Person {
    public void study() {
        System.out.println("Good Good Study,Day Day Up");
    }
}

class PersonTest2 {
    public static void main(String[] args) {
        //需求：我要测试Person类中的study()方法
        PersonDemo pd = new PersonDemo();
        Person p = pd.getPerson(); //new Student();  Person p = new Student(); 多态
        p.study();
    }
}

接口做返回：

interface Love {
    public abstract void love();
}

class LoveDemo {
    public Love getLove() {
        //Love l = new Teacher();
        //return l;
        
        return new Teacher();
    }
}

//定义具体类实现接口
class Teacher implements Love {
    public void love() {
        System.out.println("老师爱学生,爱Java,爱林青霞");
    }
}

class TeacherTest2 {
    public static void main(String[] args) {
        //如何测试呢?
        LoveDemo ld = new LoveDemo();
        Love l = ld.getLove(); //new Teacher(); Love l = new Teacher(); 多态
        l.love();
    }
}

    (3)链式编程
        对象.方法1().方法2().......方法n();
        
        这种用法：其实在方法1()调用完毕后，应该一个对象；
                  方法2()调用完毕后，应该返回一个对象。
                  方法n()调用完毕后，可能是对象，也可以不是对象。

例子：

/*
    链式编程。
        每次调用完毕方法后，返回的是一个对象。
*/
class Student {
    public void study() {
        System.out.println("Good Good Study,Day Day Up");
    }
}

class StudentDemo {
    public Student getStudent() {
        return new Student();
    }
}

class StudentTest3 {
    public static void main(String[] args) {
        //如何调用的呢?
        StudentDemo sd = new StudentDemo();
        //Student s = sd.getStudent();
        //s.study();
        
        //大家注意了
        sd.getStudent().study();
    }
}

2:包(理解)
    (1)其实就是文件夹
    (2)作用：
        A:区分同名的类
        B:对类进行分类管理
            a:按照功能分 （CRUD四个功能，四个包，各自底下有学生添加，学生删除老师添加，老师删除等）
            b:按照模块分(老师包，学生包，每个包各自含自己的CRUD功能)
    (3)包的定义(掌握)
        package 包名;
        多级包用"."分开即可。
    (4)注意事项：(掌握)
        A:package语句必须在文件中的第一条有效语句
        B:在一个java文件中，只能有一个package
        C:如果没有package，默认就是无包名
    (5)带包的编译和运行
        A:手动式

             a.编写一个带包的java文件

             b.通过javac命令编译该java文件

             c.手动创建包名

             d.把b步骤的class文件放到C步骤的最底层包

             e:回到和包根目录在同一目录的地方，然后运行，记住带包运行。java cn.itcast.HelloWorld
        B:自动式(掌握)
            javac -d . HelloWorld.java (-d:创建目录，"."表示在本路径下创建)

            1.编写一个带包的java文件

            2.javac编译的时候带上-d即可

                    javac -d . HelloWorld.java
            3.回到和包根目录在同一目录的地方，然后运行，记住带包运行java cn.itcast.HelloWorld

          

            不同包下类之间的访问：先编译引入包的java文件，再编译执行包下的java文件，再带包运行

          
3:导包(掌握)
    (1)我们多次使用一个带包的类，非常的麻烦，这个时候，Java就提供了一个关键字import。
    (2)格式：
        import 包名...类名; //这种方式导入是到类的级别
        另一种：
            import 包名...*;(不建议)
    (3)package,import,class的顺序
        package > import > class

        package:只能有一个

        import：可以有多个

        class：可以有多个，以后建议是一个
    
4:权限修饰符(掌握)
    (1)权限修饰符
                      　　本类    同一个包下（包含子类与无关类）    不同包下的子类    不同包下的无关类
        private           Y
        默认               Y            Y
        protected       Y            Y                  　　　　　　　　　　Y
        public             Y            Y                 　　　　　　　　　　 Y                       Y
    (2)这四种权限修饰符在任意时刻只能出现一种。
        public class Demo {}        

5:常见的修饰符(理解)
    (1)分类：
        权限修饰符：private,默认,protected,public
        状态修饰符：static,final
        抽象修饰符：abstract
    (2)常见的类及其组成的修饰
       修饰符：
        权限修饰符：private，默认的，protected，public
        状态修饰符：static，final
        抽象修饰符：abstract
        
    类：
        权限修饰符：默认修饰符，public
        状态修饰符：final
        抽象修饰符：abstract
        
        用的最多的就是：public

       //此处不允许使用修饰符private
　　//此处不允许使用修饰符protected
　　//此处不允许使用修饰符static

       
    成员变量：
        权限修饰符：private，默认的，protected，public
        状态修饰符：static，final
        
        用的最多的就是：private
        
    构造方法：
        权限修饰符：private，默认的，protected，public
        
        用的最多的就是：public
        
    成员方法：
        权限修饰符：private，默认的，protected，public
        状态修饰符：static，final
        抽象修饰符：abstract
        
        用的最多的就是：public
        
    除此以外的组合规则：
        成员变量：public static final
        成员方法：public static
                  public abstract
                  public final
       
    (3)另外比较常见的：
        public static final int X = 10;
        public static void show() {}
        public final void show() {}
        public abstract void show();

6:内部类(理解)
    (1)把类定义在另一个类的内部，该类就被称为内部类。
        举例：把类B定义在类A中，类B就被称为内部类。
    (2)内部类的访问规则
        A:可以直接访问外部类的成员，包括私有
        B:外部类要想访问内部类成员，必须创建对象
    (3)内部类的分类 （注意：类与类是平级关系）
        A:成员内部类：在成员位置定义的类，被称为成员内部类
        B:局部内部类：在局部位置定义的类，被称为局部内部类
    (4)成员内部类  （外部类没有static作为修饰，而内部类则可以用static修饰，因为内部类把他看做外部类的成员来看待，成员是可以用静态修饰的）
         A:private 为了保证数据的安全性  身体类（包含心脏类，肝脏类，肺类等，这些都用私有内部类）
        B:static 为了让数据访问的方便性  ,内部类用静态修饰是因为内部类可以看出是外部类的成员，一般使用static修饰内部类的话，会用public作为访问修饰符，因为已经在类加载是加载了，算是顶层类，一般这样用不用构造方法，直接类名加方法就好了，所以，一般公用的才使用public

               被静态修饰的成员内部类只能访问外部类的静态成员

              内部类方法被静态修饰后的方法：1.静态方法2.非静态方法
        
        成员内部类不是静态的：
            外部类名.内部类名 对象名 = new 外部类名().new 内部类名();  例子：Outer.Inner oi = new Outer().new Inner();
        成员内部类是静态的：
            外部类名.内部类名 对象名 = new 外部类名.内部类名();  例子：Outer.Inner oi = new Outer.Inner();   

　　(5)成员内部类的面试题(填空) 

/*
    　　面试题：
        　　　　要求请填空分别输出30，20，10。
        
    　　注意：
        　　　　1:内部类和外部类没有继承关系。
        　　　　2:通过外部类名限定this对象
            　　　　　　Outer.this
*/
class Outer {
    public int num = 10;
    class Inner {
        public int num = 20;
        public void show() {
            int num = 30;
            System.out.println(num);  //就近原则下的num
            System.out.println(this.num);  //本类下的成员变量num
            //System.out.println(new Outer().num);   //这句是可以的，创建一个匿名对象调用变量，但不是最简单，最简单在下面
            System.out.println(Outer.this.num);  //利用Outer.this,限制this的范围，来访问Outer下的num
        }
    }
}
class InnerClassTest {
    public static void main(String[] args) {
        Outer.Inner oi = new Outer().new Inner();
        oi.show();
    }    
}

    (6)局部内部类(这个点很容易被忽视)

        可以直接访问外部类的成员
        可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能
        局部内部类访问局部变量的注意事项：
        A:局部内部类访问局部变量必须加final修饰。
        B:为什么呢?
            因为局部变量是随着方法的调用而调用，随着调用完毕而消失。而堆内存的数据并不会立即消失。
            所以，堆内存还是用该变量，而该变量已经没有了。
            为了让该值还存在，就加final修饰。
            通过反编译工具我们看到了，加入final后，这个变量就成了常量，堆内存直接存储的是值，而不是变量名。
局部内部类例子，面试题：

/*
    局部内部类
        A:可以直接访问外部类的成员
        B:在局部位置，可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能
    
    面试题：
        局部内部类访问局部变量的注意事项?
        A:局部内部类访问局部变量必须用final修饰
        B:为什么呢?
            局部变量是随着方法的调用而调用，随着调用完毕而消失。
            而堆内存的内容并不会立即消失。所以，我们加final修饰。
            加入final修饰后，这个变量就成了常量。既然是常量。你消失了。
            我在内存中存储的是数据20，所以，我还是有数据在使用。
*/
class Outer {
    private int num  = 10;
    
    public void method() {
        //int num2 = 20;  //jdk报错，说明一定要final作为局部变量的修饰
        final int num2 = 20;//对的
        class Inner {
            public void show() {
                System.out.println(num);
                //从内部类中访问本地变量num2; 需要被声明为最终类型,可以利用反编译穿软件看看，是否直接变为20，连变量名都消失了
                System.out.println(num2);//20
            }
        }
        
        //System.out.println(num2);
        
        Inner i = new Inner();
        i.show();
    }
}

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

　　(7)匿名内部类(掌握)
        A:其实是局部内部类的简化形式
        B:前提
            存在一个类或者接口，这里的类可以是具体类也可以是抽象类
        C:格式:
            new 类名或者接口名() {
                重写方法;
            }
        D:本质：
            其实是继承该类（具体类对象）或者实现接口的子类（实现类）匿名对象

        E:好处：在使用匿名对象或匿名内部类时，都是一次定义，一次使用就不会用了，所以不用创建引用变量指向对象引用地址，匿名的使用能让jvm的垃圾回收机制快点收回内存，因为它没有被栈的变量所指向，所以回收速度最快。

          弊端：只能使用一次
  

    (8)匿名内部类在开发中的使用
        我们在开发的时候，会看到抽象类，或者接口作为参数。
        而这个时候，我们知道实际需要的是一个子类对象。
        如果该方法仅仅调用一次，我们就可以使用匿名内部类的格式简化。
       例子：

/*
    匿名内部类在开发中的使用
*/
interface Person {
    public abstract void study();
}

class PersonDemo {
    //接口名作为形式参数
    //其实这里需要的不是接口，而是该接口的实现类的对象
    public void method(Person p) {
        p.study();
    }
}

//实现类
class Student implements Person {
    public void study() {
        System.out.println("好好学习,天天向上");
    }
}

class InnerClassTest2 {
    public static void main(String[] args) {
        //测试
        PersonDemo pd = new PersonDemo();
        Person p = new Student();
        pd.method(p);
        System.out.println("--------------------");
        
        //匿名内部类在开发中的使用
        //匿名内部类的本质是继承类或者实现了接口的子类匿名对象
        pd.method(new Person(){
            public void study() {
                System.out.println("好好学习,天天向上");
            }
        });
    }
}

    (9)匿名内部类的面试题(补齐代码)
/*
    匿名内部类面试题：
        按照要求，补齐代码
            interface Inter { void show(); }
            class Outer { //补齐代码 }
            class OuterDemo {
                public static void main(String[] args) {
                      Outer.method().show();
                  }
            }
            要求在控制台输出”HelloWorld”
*/
interface Inter {
    void show();
    //public abstract
}

class Outer {
    //补齐代码
    public static Inter method() {
        //子类对象 -- 子类匿名对象
        return new Inter() {
            public void show() {
                System.out.println("HelloWorld");
            }
        };
    }
}

class OuterDemo {
    public static void main(String[] args) {
        Outer.method().show();
        /*
            1:Outer.method()可以看出method()应该是Outer中的一个静态方法。
            2:Outer.method().show()可以看出method()方法的返回值是一个对象。
                又由于接口Inter中有一个show()方法,所以我认为method()方法的返回值类型是一个接口。
        */
    }
}