2017.4.16 形参，返回值，内部类

          

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

 形式参数：
  基本类型：要的是该基本类型的数据值。
  引用类型：要的是该引用类型的对象。

 

package com.edu_01;

public class ArgsDemo {
 public static void main(String[] args) {
  //在这里我们调用我们刚刚创建的数组遍历的方法
  //A:数组 要的是该数据类型数组的对象。(地址值)
  //创建一个数组
  int[] arr = {1,2,3};
  printArr(arr);
 }
 
 //A:数组 要的是该数据类型数组的对象。(地址值)
 //写一个方法是一个数组遍历的方法
 public static void printArr(int[] arr){
  for (int i = 0; i < arr.length; i++) {
   System.out.print(arr[i]+"  ");
  }
 }

}

   A:数组 要的是该数据类型数组的对象。(地址值)

package com.edu_01;
B:类   要的是该类或者其子类的对象。(地址值)
class Person{
 public void show(){
  System.out.println("person的show方法");
 }
}

class Man extends Person{
 public void show(){
  System.out.println("Man的function方法");
 }
}

class PersonDemo{
 //提供一个方法，这个方法的参数是Person
 public void method(Person p){//Person p = new Person();
         //当传递子类对象的时候，Person p = new Man();,这个是以多态的方式进行传参
  p.show();//p.show();
 }
}

public class ArgsDemo2 {
 public static void main(String[] args) {
  //想要调用PersonDemo这个类中的method方法
  PersonDemo pd = new PersonDemo();
  Person p = new Person();
  Man m = new Man();
  pd.method(m);
  Person p2=new Man();
  pd.method(p2);
  //p.show();
  pd.method(p);
  
 }

}

   
   C:抽象类 要的是该抽象类的子类对象。(地址值)

package com.edu_01;
abstract class Animal{
 public abstract void eat();
}

//创建一个Animal类的子类
class Dog extends Animal{
 @Override
 public void eat() {
  System.out.println("狗爱啃骨头");
 }
 
}

class AnimalDemo{
 public void method(Animal a){          //Aanimal a = new Dog();多态的方式进行传参
                                                    //注意：如果一个形式参数类型是一个抽象类的话，本质上要的是这个抽象类的子类对象
  a.eat();
 }
}

public class ArgsDemo3 {
 public static void main(String[] args) {
  //需要调用AnilaDemo这个类中的method这个方法
  AnimalDemo ad = new AnimalDemo();
  Animal a = new Dog();
  ad.method(a);
 }

}

   D:接口 要的是该接口的实现类对象。(地址值)

package com.edu_01;
interface Person2{
 public abstract void eat();
}

class Women implements Person2{
 @Override
 public void eat() {
  System.out.println("民以食为天");
 }
}

class Person2Demo{
 public void method(Person2 p){   //Perosn2 p = new Women();接口多态的方式进行传参
      //注意：如果一个方法的形式参数是一个接口类型的话，本质上需要的是这个接口的实现类对象，其实就是这个对象的地址值
  p.eat();
 }
}

public class ArgsDemo4 {
 public static void main(String[] args) {
  //调用Peros2Demo中的method方法
  Person2Demo pd = new Person2Demo();
  Person2 p = new Women();
  pd.method(p);
 }

}

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

 返回值之基本类型：
  基本类型：返回的是该基本类型的数据值。
  案例：创建一个加法的方法，返回值就是基本类型的具体的指

package com.edu_02;

public class RetrunDemo {
 public static void main(String[] args) {
  //调用这个家法
  System.out.println(add(1, 2));
 }
 
 //创建一个方法，可以做两个数的加法，并返回两个数的和
 public static int add(int a,int b){
  return a+b;
 }
 
}

 
 返回值之引用类型：
A: 返回值是类名：其实返回的是该类对象或者其子类对象。(地址值)

package com.edu_02;

class Person{
 public void show(){
  System.out.println("perosn的show方法");
 }
}

class Student extends Person{
 public void show(){
  System.out.println("Student的function方法");
 }
}

class PersonDemo{
 //有一个方法，方法的返回值就是一个Person类型
 public Person getPerson(){//Person p = new Person();
  //返回值类型如果是一个类名：本质上需要的是这个类或者这个类的子类对象
  //Person p = new Person();
  //Student s = new Student();//Person p = new Student();
  Person s=new Person();
  return s;
 }
 
}

public class ReturnDemo2 {
 public static void main(String[] args) {
  //调用PersonDemo这个类中的getPerson()方法
  /*PersonDemo pd = new PersonDemo();
  Person p = pd.getPerson();//Person p = new Person()
  p.show();*/
  
  PersonDemo pd = new PersonDemo();
  Person s = pd.getPerson();//Person p = new Studnet();,多态
  //p.show();
  //p.function();
  //Student s = (Student)p;
  //s.function();
  s.show();
 }

}

B: 返回值是抽象类名：要的是该抽象类的子类对象。(地址值)

package com.edu_02;
abstract class Animal{
 public abstract void eat();
}

class Dog extends Animal{
 @Override
 public void eat() {
  System.out.println("狗就是爱吃骨头");
 }
}

class AnimalDemo{
 //提供以一个方法，这个方法的返回值类型就是一个抽象类名
 public Animal getAnimal(){//Animal a = new Dog();
  //注意：返回值类型是一个抽象类名的话：本质上需要的是这个抽象类的子类对象
  //Animal a = new Dog();
  Dog a = new Dog();
  return a;
 }
 
}

public class ReturnDemo3 {
 public static void main(String[] args) {
  //在这里调用ANimalDemo中的getAnimal的方法
  AnimalDemo ad = new AnimalDemo();
  Animal a = ad.getAnimal();//Animal a = new Dog();
  a.eat();
 }

}

D： 返回值是接口名：要的是该接口的实现类对象。(地址值)

package com.edu_02;
//创建一个接口
interface Person2{
 public abstract void eat();
}

//创建一个类实现上面的接口
class Man implements Person2{
 @Override
 public void eat() {
  System.out.println("我爱吃泡馍");
 }
}

class Person2Demo{
 //提供一个方法，该方法的返回值是一个接口类型
 //注意：如果一个方法的返回值是接口类型的话，本质上需要的是该接口的实现类对象
 public Person2 getPerson2(){//Person2 p = new Man();
  Person2 p = new Man();
  return p;
 }
}

public class ReturnDemo4 {
 public static void main(String[] args) {
  //调用Person2Demo中的getPersaon2()
  Person2Demo pd = new Person2Demo();
  Person2 p = pd.getPerson2();//Person2 p = new Man();,接口多态
  p.eat();
 }

}

  
 
三：权限修饰符（代码进行测试）
 权限修饰符：在哪种情况下可以被访问到。
                                  本类              同一个包下的类         不同包下的子类      不同包下的无关类

  private                      yes                           no                             no                       no
  默认(什么都不写)     yes                           yes                            no                       no
  protected                 yes                            yes                           no                        no
  public                       yes                           yes                           yes                     yes

四：常见的内容修饰
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:哪些东西可以修饰哪些东西
                      类               成员变量            构造方法           成员方法
 private          no                 yes                   yes                    yes
 默认              yes               yes                   yes                     yes
 protected      no                 yes                   yes                     yes
 public           yes                 yes                  yes                     yes
 static           no                  yes                    no                      yes
 final              yes                 yes                 no                       yes
 abstract        yes                 no                                             yes

 注意：
  四种权限修饰符，只能有一种存在。

  class Demo {}

 常见的组合：
  类：
   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:外部类要访问内部类的成员，必须创建对象。

package com.edu_05;
/**
 5.1
 内部类：
  把类A定义在类B的内部，类A就被称为内部类。

 访问特点：（代码验证只要编译通过说明就是没有问题的）
  A:内部类可以直接访问外部类的成员，包括私有。
  B:外部类要访问内部类的成员，必须创建对象。
 */
//创建一个外部类
class Outer{
 //私有画的成员变量
 private int num = 20;
 
 //创建一个内部类
 class Inner{
  //创建一个show方法，访问外部类的私有化的成员变量
  public void show(){
   System.out.println(num);//内部类的成员可以直接访问外部类的成员，包括私有
  }
 }
 
 //创建一个成员方法，访问内部类的show方法
 public void function(){
  //创建内部类的对象，访问内部类的成员方法
  Inner i = new Inner();
  i.show();
 }
}

public class InnerClassDemo {
 public static void main(String[] args) {
  //创建一个外部类对象，调用他的function方法
  Outer o = new Outer();
  o.function();
 }

}

 5.2
 内部类分类：
  成员位置：成员内部类
  局部位置：局部内部类

 

class Outer2{
 //创建一个成员内部类,位置在类中方法外，也就是类的成员位置
 class Inner2{}
 
 //创看一个局部内部类，位置位于方法内，也就是局部位置
 public void show(){
  //方法中存在一个类，叫局部内部类
  class Inner22{}
 }
 
}

public class InnerClassDemo2 {

}

 
 5.2.1
 成员内部类：
  外界如何创建对象

  外部类名.内部类名 对象名 = 外部类对象.内部类对象;

class Outer3{
 //创建一个成员内部类
 class Inner3{
  public void show(){
   System.out.println("inner3的show()"); 
  }
 }
 
}

public class InnerClassDemo3 {
 public static void main(String[] args) {
  //需求：创建上面的内部类对象，调用他的show方法
  //创建内部类对象的格式：外部类名.内部类名     对象名 = 外部类对象.内部类对象
  Outer3.Inner3 oi = new Outer3().new Inner3();
  oi.show();
 }

}

 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();

 成员内部类的修饰：
  A:private 为了我们访问数据的安全性
  B:static  为了我们访问数据的方便性
 
 
 5.2.3
 //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();//当时用static时，其创建对象的方式也发生变化，
   oi.show();
   oi.show2();

   //Outer.Inner.show();
   Outer.Inner.show2();
  }
 }
 
 
 5.2.4
 面试题：
 /*
 需求：请补齐代码，在控制台输出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);//num
    System.out.println(this.num);//this.num
    System.out.println(new Outer().num);

    System.out .println(Outer.this.num);                 ;//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:在成员方法中创建局部内部类的对象，调用局部内部类的功能

 面试题：
  从内部类中访问本地变量number; 需要被声明为最终类型?//利用final关键字，将number转换为常量，存储于常量池中

  为什么：局部内部类访问局部变量必须加final修饰呢?
   因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。
   为了让数据还能继续被使用，就用fianl修饰，这样，在堆内存里面存储的其实是一个常量值。
 
 5.4
 匿名内部类
  没有名字的局部内部类,就是内部类的简化写法

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

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

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

interface Animal{
 public abstract void eat();
}

//创建一个外部类
class Outer2{
 //创建一个show方法，方法中存在一个匿名内部类
 public void show(){
  //匿名内部类
  //匿名内部类格式：new 类或者接口(){重写的方法}
  //匿名内部类本质：就是一个继承了类 ，或者实现了接口 ，的子类或者实现类的匿名对象
  new Animal(){
   @Override
   public void eat() {
    System.out.println("动物爱吃肉");
   } 
  }.eat();
 }
}

public class InnerClassDemo2 {
 public static void main(String[] args) {
  //创建一个Outer2这个外部类对象
  Outer2 o2 = new Outer2();
  o2.show();
 }

}

  
 5.5
 匿名内部类在开发中的实际应用。
 案例演示：传入的方法的参数是一个接口（方式一：定义一个已经实现了接口的类  方式二：匿名内部类的方式）
  

interface Person2{
 public abstract void eat();
}

class Man2 implements Person2{
 @Override
 public void eat() {
  System.out.println("男人都爱吃泡馍");
 }
}

class Person2Demo{
 //创建一个方法，方法的参数是一个接口类型
 public void show(Person2 p){
  p.eat();
 }
}

public class InnerClassDemo4 {
 public static void main(String[] args) {
  //调用Person2Demo中的show方法
  Person2Demo pd2 = new Person2Demo();
  pd2.show(new Man2());//传入接口的实现类对象
  
  System.out.println("--------------------");
  //使用匿名内部类的方式进行传参
  pd2.show(new Person2(){//这里的匿名内部类，本质上就是实现了Person2这个接口的一个实现类对应的匿名对象
   @Override
   public void eat() {
    System.out.println("我爱吃油泼面");
   }
  });
 }

}

 
 5.6面试题
 /*
 按照要求，补齐代码
  interface Inter { void show(); }
  class Outer { 

public static Inter method(){

return   new Inter(){

public void show(){

System.out.println("HelloWorld");

     }};

   }

}
  class InnerClassTest {
   public static void main(String[] args) {
      Outer.method().show();
     }
  }
 要求在控制台输出”HelloWold“

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