知识点回顾（形参.内部类...)

形式参数问题

数据类型：
  基本类型：byte,short,int,long,float,double,char,boolean
  引用类型：类,接口,数组

 形式参数：
  基本类型：要的是该基本类型的数据值。
  引用类型：要的是该引用类型的对象。
   A:数组 要的是该数据类型数组的对象。(地址值)
   B:类   要的是该类或者其子类的对象。(地址值)
   C:抽象类 要的是该抽象类的子类对象。(地址值)
   D:接口 要的是该接口的实现类对象。(地址值)

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]+"  ");}}}

package com.edu_01;//B:类   要的是该类或者其子类的对象。(地址值)class Person{public void show(){System.out.println("person的show方法");}}class Man extends Person{public void function(){System.out.println("Man的function方法");}}class PersonDemo{//提供一个方法，这个方法的参数是Personpublic 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方法

package com.edu_01;//C:抽象类要的是该抽象类的子类对象。(地址值)abstract class Animal{public abstract void eat();}//创建一个Animal类的子类class Dog extends Animal{@Overridepublic 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);}}

package com.edu_01;//D:接口要的是该接口的实现类对象。(地址值)interface Person2{public abstract void eat();}class Women implements Person2{@Overridepublic 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);}}

PersonDemo pd = new PersonDemo();//Person p = new Person();Man m = new Man();pd.method(m);

  }

}

返回值及权限修饰符

返回值：
  基本类型：byte,short,int,long,float,double,char,boolean                                                  权限修饰符：在哪种情况下可以被访问到
  引用类型：类，接口，数组                                                                                                    本类     同一个包下的类   不同包下的子类  不同包下的无关类

                                                                                                                                             private              yes                     no                         no

 返回值之基本类型：
  基本类型：返回的是该基本类型的数据值。                                                                   默认(什么都不写)    yes       yes      no         no                                                                     
  案例：创建一个加法的方法，返回值就是基本类型的具体的指                                       
 
 返回值之引用类型：                                                                                                      protected   yes             yes         no      no
 返回值是类名：其实返回的是该类对象或者其子类对象。(地址值)                               public                       yes                yes          yes
 返回值是抽象类名：要的是该抽象类的子类对象。(地址值)
 返回值是接口名：要的是该接口的实现类对象。(地址值)                                           yes

常见内容修饰

1:常见的修饰                                                                                              常见的组合：
  
 类：public                                                                                             类：public class HelloWorld {}
  public class HelloWorld {}                                                                           public final class HelloWorld {}                                               

                                                                                                                     public abstract class HelloWorld {}

 成员变量：private                                                                      成员变量：     
  private String name;                                                                               private String name;                                                                        
  private int age;                                                                                        public final int X = 10;

                                                                                                                 public static int y = 20;

 构造方法：public                                                                                    public static final int X = 30;
  public Student() {}                                                                     成员方法：
  public Student(String name,int age) {}                                                   public void show(){}

                                                                                                                 public abstract void show();

 成员方法：public                                                                                    public final void show(){}
  public void show() {}                                                                              public static void show() {}
  public void eat() {}                                                                                 public static final void show() {}

    

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

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

  内部类

五：内部类
 5.1
 内部类：
  把类A定义在类B的内部，类A就被称为内部类。

 访问特点：（代码验证只要编译通过说明就是没有问题的）
  A:内部类可以直接访问外部类的成员，包括私有。
  B:外部类要访问内部类的成员，必须创建对象。

 5.2
 内部类分类：
  成员位置：成员内部类
  局部位置：局部内部类
 
 5.2.1
 成员内部类：
  外界如何创建对象

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

package com.edu_05;/** * 5.2内部类分类：成员位置：成员内部类局部位置：局部内部类 * *///创建一个外部类class Outer2{//创建一个成员内部类,位置在类中方法外，也就是类的成员位置class Inner2{}//创看一个局部内部类，位置位于方法内，也就是局部位置public void show(){//方法中存在一个类，叫局部内部类class Inner22{}}}public class InnerClassDemo2 {}

5.3
 局部内部类：
 A:可以直接访问外部类的成员，包括私有
 B:在成员方法中创建局部内部类的对象，调用局部内部类的功能

package com.edu_06;/** * 5.3局部内部类：A:可以直接访问外部类的成员，包括私有B:在成员方法中创建局部内部类的对象，调用局部内部类的功能 * */class Outer{//创建一个外部类的私有化的成员变量private int num = 30;//创建一个show方法，show方法内部有一个局部内部类public void show(){//设置一个show方法的局部变量final int num2 = 40;//num2被加上final之后，num2变成了常量，其实本质上他就是40//创建局部内部类class Inner{//存在一个function方法public void function(){System.out.println(num2);//System.out.println(40);//编译：java -- class//反编译：class -- java/** * 问题：局部内部类的成员方法访问局部变量的时候，局部变量为什么必须加上final就不报错了呢？？ * 我们的show方法在调用的时候存在于栈内存，当show方法调用完毕之后，他的局部变量num2会随着show * 方法调用完毕二消失，但是现在存在一个问题，show方法中的局部对象不会立即从栈内存中直接释放掉，他还保留着num2, * 此时就发生了矛盾，局部对象想使用这个num2这个变量，但是他又急着从栈内存中消失。。。，所以我们需要给num2加上final关键字 * 是他变为常量 */}}//需求：在show方法中调用局部内部类的function方法//创建局部内部类对象Inner i = new Inner();i.function();}}public class InnerClassDemo {public static void main(String[] args) {//需求：调用Outer外部类的show方法//创建外部类对象Outer o = new Outer();o.show();}}

5.4
 匿名内部类
  没有名字的局部内部类,就是内部类的简化写法

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

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

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

5.5匿名内部类在开发中的实际应用。案例演示：传入的方法的参数是一个接口（方式一：定义一个已经实现了接口的类  方式二：匿名内部类的方式） */interface Person2{public abstract void eat();}class Man2 implements Person2{@Overridepublic void eat() {System.out.println("男人都爱吃泡馍");}}class Person2Demo{//创建一个方法，方法的参数是一个接口类型public void show(Person2 p){p.eat();}}

例题

package com.edu_07;//要求在控制台输出”HelloWorld”interface Inter { void show(); }class Outer { //补齐代码 //创建method()是静态的public static Inter method(){return new Inter(){@Overridepublic void show() {System.out.println("helloworld");}};}}class InnerClassTest {public static void main(String[] args) {  Outer.method().show();  /**   * 1.method()这个方法如果可以直接通过类名实现调用的话，说明这个方法是static   * 2.Outer.method()可以紧接着调用show()说明method方法的返回值一定是一个Inter接口的实现类对象   * 3.所以这个实现类对象我们可以直接使用匿名内部类的形式去进行实现，因为匿名内部类的本质就是实现了Inter接口的一个实现类匿名对象   */  }}