JAVA学习笔记之形式参数，权限访问和内部类问题

JAVA学习笔记之形式参数，权限访问和内部类问题

1.形式参数
 数据类型分为基本类型(四类八种)和引用类型(类，接口，数组)，形式参数也分为基本类型和引用类型，两者有区别。
 形式参数的基本类型为：
      char; byte,short,int,long; double,float; boolean;
     引用类型：
      A,数组(实质上是该数组对象的引用，即地址值)
      B,类(实质上是该类对象(或子类对象)的引用，即地址值)
      C,接口(实质上是该接口的实现类对象的引用，即地址值)
      D，抽象类(实质上是该抽象类子类对象的引用，即地址值)
例如：
 interface Person{
  public abstract sleep();
 }
 class XiaoMing implements Person{
  public void sleep(){
   System.out.println("小明站着睡觉!");
  }
 }
 class PersonDemo{
  public void Test(Person p){
   p.sleep;
  }
 }
 class ArgsDemo{
  public static void main(String[] args){
   PersonDemo pd = new PersonDemo();
   Person p = new XiaoMing();//在这里我们对需要出送的形式参数
   pd.Test;    //进行实例化，真正传输的是对象的引用；
  }
 }
2.返回值问题
 返回值：
  基本类型：char; byte,short,int,long; double,float; boolean;
    返回的是改基本类型的数据值
    例如：
     class Demo{
      public static void main(String[] args){
       System.out.println(add(1,2));
       
       public static int add(int a,int b){
        return a+b;
       }
      }
     }
  
  引用类型：数组，类，抽象类，接口
   返回值是类名:该类对象(或子类对象)的引用，即地址值
   返回值是抽象类:是该抽象类子类对象的引用，即地址值
   返回值是接口:该接口的实现类对象的引用，即地址值
   例如:
    interface Person{
     public void sleep();
    }
    
    class XiaoMing implements Person{
     public void sleep(){
     System.out.println("小明站着睡");
     }
    }
    class Demo{
     public Person method(){
      Person p = new XiaoMing();
      return p;
     }
    }
    public class Test{
     public static void main(String[] args){
      Demo d = new Demo();
      Person p = d.method();
      p.sleep();
     }
    }
3.权限访问
 在JAVA中权限访问可以通过权限访问控制关键词进行操作————public,默认，protected,private;它们的具体访问权限控制如下：
       本类     同一个包下的类   不同包下的子类  不同包下的无关类
  private    yes    no     no      no
  默认(什么都不写) yes    yes     no      no
  protected   yes             yes         no      no
  public    yes             yes     yes      yes
   
  注意：四种权限修饰符只能有一种存在 
4.内部类
 定义：顾名思义，内部类就是定义在类内部的类
 分类：成员内部类，局部内部类，匿名内部类
 内部类关键词限定：相对于普通的类来说，内部类可以被private,static修饰
 A.成员内部类
  位置：位于类中的成员位置
  创建方法：外部类名.内部类名 对象名 = new 外部类对象.内部类对象;
   static修饰时：外部类名.内部类名 对象名 = new 外部类类名.内部类对象;
  例子：
   class Outerr {
    public int num = 10;
    private class Inner {
     public int num = 20;
     public void show() {
      int num = 30;
      System.out.println(num);//num
      System.out.println(this.num);//this.num
      System.out.println(new Outerr().num);//或者Outer.this.num
     }
    }
    public void method() {
     Inner i = new Inner();
     i.show();
     }
   }
   class InnerClassTest {
    public static void main(String[] args) {
     Outerr o = new Outerr();
     o.method();
    }
   }
 B.局部内部类
  位置：位于类中方法中，可以直接访问外部类成员，包括私有；在成员。
  注意：局部内部类访问局部变量必须加final修饰，因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。为了让数据还能继续被使用，就用fianl修饰，这样，在堆内存里面存储的其实是一个常量值。
   
  例子：
   class Outer{
     private int num = 30;
     public void show(){
      final int num = 40;
      class Inner{
       public void function(){
        System.out.println(num);
        System.out.println(new Outer().num);
       }
      }
      Inner i = new Inner();
      i.function;
     }
   }
   public class InnerClassDemo{
    public void main(String[] args){
    Outer o = new Outer();
    o.show;
    }
   }
 C.匿名内部类
  位置：位于类中方法中，是一种没有名字的局部内部类，就是内部类的简化写法
  前提：存在一个类或者接口；这里的类可以是普通类，也可以是抽象类
  格式：
   new 类名或接口名(){
    重写方法;
   };
   
  本质：继承类或实现接口的子类匿名对象
  例子：
   interface Inter{
    void show();
   }
   class Outer{
    public static Inter method(){
     retrun new Inter(){
      public void show(){
       System.out.println("HelloWorld");
      }
     };
    }
   }
   public class InnerClassTest{
    public static void main(String[] args){
     Outer.method().show();
    }
   }