IDEA中Java的一些操作和内部类

知识模块
1.IDEA中的其他操作
2.引用类型作为方法的形参和返回值
3.内部类



1.IDEA中的其他操作
    a.IDEA的其他快捷键
      ctrl+N：根据名称搜索所有模块/工程下的类或接口
      ctrl+shift+N:根据名称搜索所有模块/工程下的 文件
      ctrl+H：看类或接口的继承体系
      ctrl+F12：展示该类的所有成员，而且可以搜索，直接跳转
      ctrl+鼠标左键：可以快速跳转到选中类/接口/方法/变量的定义位置

    b.IEDA导出jar包
      jar包本质上就是一个压缩包，jar包中一般存放.java或.class源文件
    c.IDEA导入jar包
      jar包中含有很多类.class文件，如果将.class文件一个一个传送给他人使用，非常繁琐
      而把jar包传输给别人，别人只需要引用这个jar包，就可以使用里面所有的.class文件

2.引用类型作为方法的形参和返回值

   a.普通类作为方法的形参和返回值
        当我们传递一个引用变量或者匿名对象给方法的形参，其实传递都是对象的地址值
        当我们在方法中返回一个引用变量或者匿名对象，其实返回的是这个对象的地址值
   b.抽象类作为方法的形参和返回值
        当抽象类作为方法的形参只能接受子类对象，本质上接受的是子类对象的地址值
        在该方法中使用这个形参遵循多态原则
        当抽象类作为方法的返回值类型时候，只能返回子类对象，本质上返回的是子对象的地址值
        再返回到调用处使用引用变量，依然遵循多态原则
   c.接口作为方法的形参和返回值
           当接口作为方法的形参只能接受实现类对象，本质上接受的是实现类对象的地址值
           在该方法中使用这个形参遵循多态原则
           当接口作为方法的返回值类型时候，只能返回实现类类对象，本质上返回的是实现类对象的地址值
           再返回到调用处使用引用变量，依然遵循多态原则

3.内部类
    内部类顾名思义，就是在一个类的内部在定义一个类
    因为有些事物的内部还含有其他食物，因此我们需要通过内部类的形式更加贴近于现实生活描述

    //人类
    class Person{
       //姓名，年龄
       //吃饭
    }
    //心脏
    class Heart{
       //左心房，右心房
       //跳动
    }

    Person{
       //姓名，年龄
       //吃饭
       //心脏
       class Heart{
             //左心房，右心房
             //跳动

       }
    }
    a.成员内部类
         成员内部类：定义在成员位置（类中方法外）上的类
                   可以用权限修饰符
         成员内部类编译好后的形式：  外部类名$内部类名.class

            内部类中的成员调用格式
               外部类名.内部类名  引用变量名=new 外部类(参数）.new内部类(参数);
               引用变量名调用内部类成员
         我们需要通过  外部类.this 和内部类.this 区分

/*
  成员内部类：定义在成员位置（类中方法外）上的类
            可以用权限修饰符
  成员内部类编译好后的形式：  外部类名$内部类名.class
 */
public class Person {
   // private int i = 3;

     class Heart {//成员内部类

         public void jump() {
             System.out.println("心脏在跳动");
         }
    }

    /*public void method() {

    }*/
}

/*
   内部类中的成员调用格式
      外部类名.内部类名  引用变量名=new 外部类(参数）.new内部类(参数);
      引用变量名调用内部类成员
 */
public class Demo01 {
    public static void main(String[] args) {
        Person.Heart ph = new Person().new Heart();
        ph.jump();
    }
}

    b.局部内部类
          局部内部类：定义在局部位置
          局部内部类编译好的形式： 外部类$编号内部类名.class

/*
  局部内部类：定义在局部位置
  局部内部类编译好的形式： 外部类$编号内部类名.class
 */
public class Demo04 {
    public void method() {
        class Inner{

        }
        new Inner();
    }
}

    c.匿名内部类
      匿名对象：  new 类名（参数）
      匿名内部类：
           格式：
              new 父类或 父接口（）{
                 //重写父类或父接口方法
              }

         匿名内部类的原理：
            1.自动生成一个内部类 Demo06$1.class
               class Demo06$1 implements Smoke{
                public void smoking() {
                    System.out.println("饭后一根烟，赛过活神仙");
                }
               }
            2.会创建Demo06$1的对象
               new Demo06$1();

               //其实相当于 Smoke s=new Demo06$1();
           Smoke s= new Smoke() {
                public void smoking() {
                    System.out.println("饭后一根烟，赛过活神仙");
                }
            };

        匿名内部类为了简化创建实现类

public interface Smoke {
    void smoking();
}

public class Student implements Smoke {
    @Override
    public void smoking() {
        System.out.println("吸烟有害健康");
    }
}

public class Demo05 {
    public static void main(String[] args) {
        /*Student student = new Student();
        student.smoking();*/
        Smoke s = new Student();//父接口指向实现类对象//多态的形式
        s.smoking();
    }
}

public class Demo06 {
    public static void main(String[] args) {
    /*   Smoke s= new Smoke() {//父接口指向实现类对象  Smoke s=new Demo06$1();
                             //遵循多态
            public void smoking() {
                System.out.println("c");
            }
        };
       s.smoking();*/
        new Smoke() {//new Demo06￥1.smoking();
            @Override
            public void smoking() {
                System.out.println("饭后一根烟，赛过活神仙");
            }
        }.smoking();
    }
}