形式参数-返回值-内部类-匿名内部类

一.形式参数和返回值

1.基本数据类型：

  你要什么数据类型，实际传参的时候就传什么数据类型，形式参数的改变对实际参数没有影响(String是引用类型，但和基本类型的效果一样String s = "luo")。

关于String:String a = "abc"和String s = new String("abc")的区别

在Java虚拟机(JVM)中存在着一个字符串池，其中保存着很多String对象，并且可以被共享使用，因此它提高了效率。String a = "abc"；在执行这个代码的时候，Java虚拟机首先在字符串池pool中查找是否已经存在了“abc”的这么一个对象，判断依据是String类equals(Object obj)方法的返回值。如果有，则不再创建新的对象，直接返回已存在对象的引用；如果没有，则先创建这个对象，然后把它加入到字符串池中，再将它的引用返回。

对于String s = new String("abc");语句，这里“abc”本身就是Pool中的一个对象，而在运行时执行new String()时，将pool中的对象复制一份放到堆中，并且把堆中的这个对象的引用交给s持有，创建了两个String对象。

第二种方式创建了两个String对象，增加了性能开销，所以建议避免使用这种方式创建String对象。

class Demo{//成员方法public int sum(int a,int b){return (a+b);} }public class BasicDataTest {public static void main(String[] args) {Demo d = new Demo();int result = d.sum(3, 4);      //3、4是实际的两个参数System.out.println("result = "+result);System.out.println("-------------");String str1 = "fly";String str2 = "weight";String str3 = "flyweight";String str4 = null;str4 = str1 + str2;System.out.println(str3 == str4);//false/* * str3和str4指向同一个对象，通过intern()方法来实现,会先在字符串常量池中寻找内容为“flyweight”的地址，如果找到，就将str4变量指向这个地址，如果找不到，就将创建一个字符串常量并将其加入到常量池中，此处已有这个地址，所以str4指向这个地址。即str3和str4变量指向为同一个地址，两个引用指向同一个字符串对象。*/str4 = (str1 + str2).intern();System.out.println(str3 == str4);//true}}

2.引用类型：具体类、抽象类、接口

1）具体类:

形式参数：如果形式参数是一个具体的类，那么需要创建该类对象

class Student{public void show(){System.out.println("好好学Java！");}}class StudentDemo{public void method(Student s){//形式参数是一个引用类型，那么需要该类对象Student s = new Student();s.show();}}public class ConcreteDemo {public static void main(String[] args) {//需求：调用StudentDemo中的method()方法，则需要创建StudentDemo这个类的对象StudentDemo sd = new StudentDemo();//创建Student类的对象Student s = new Student();sd.method(s);    //s代表Student类的对象，把空间地址值作为参数传递}}

返回值：方法的返回值是一个具体的类，那么需要创建该类对象

class Student{public void show(){System.out.println("好好学Java！");}}class StudentDemo{//如果方法的返回值是一个具体的类，那么需要该类的对象public Student method(){/* Student s = new Student();return s;*/return new Student();      //匿名对象}}public class ConcreteDemo {public static void main(String[] args) { //需求：调用StudentDemo中的method()方法，则需要创建StudentDemo这个类的对象StudentDemo sd = new StudentDemo();Student s = sd.method();     //返回的是一个Student类型的对象s.show();                    //再调用Student类中的show()方法}}

2）抽象类：

形式参数：需要再定义一个抽象类的子类，来进行实例化（创建对象！）创建对象的实质：抽象类多态！

//声明一个抽象类abstract class Person{public abstract void study();}//定义一个PersonDemo类class PersonDemo{//定义一个带有形参的成员方法public void method(Person p){//Person p = new Person()是错误的，因为抽象类不能实例化，//需要再声明一个抽象类的子类，通过抽象类多态实例化p.study();}}//声明抽象类的子类class Person2 extends Person{//重写抽象类中的抽象方法public void study(){System.out.println("好好学Java！");}}//测试类public class AbstractDemo {public static void main(String[] args) {//调用PersonDemo中的method()方法；PersonDemo pd = new PersonDemo();//需要使用抽象类多态实现化Person p = new Person2();pd.method(p);/*//链式编程： new PersonDemo().method(new Person2());*/}}

返回值：返回值如果是抽象类，需要返回的是该抽象类的子类对象

//声明一个抽象类abstract class Person3{public abstract void show();}//定义PersonDemo2类class PersonDemo2{public Person3 method(){//如果一个方法的返回值是一个抽象类,需要返回的是该抽象类的子类对象Person3 p = new Person4();return p;//return new Person4(); }}//抽象类的子类class Person4 extends Person3{public void show(){System.out.println("爱学习！爱Java！");}}//测试类public class ReturnAbstract {public static void main(String[] args) {//调用PersonDemo2中的method()方法PersonDemo2 pd = new PersonDemo2();Person3 p3 = pd.method();    //返回的是Person3的对象p3.show();System.out.println("---------");/* //链式编程Person3 p3 = new PersonDemo2().method();p3.show(); */}}

3）接口

形式参数：如果形式参数是接口的情况，那么需要自定义一个接口的子实现类，然后通过接口多态的形式给接口实例化！

//接口interface Inter{public abstract void love();}class TeacherDemo{public void method(Inter i){//接口不能实例化；如果一个方法的形式参数是一个接口，那么需要创建该接口的子实现类对象i.love();}}//接口不能实例化，需要定义接口的子实现类class Teacher implements  Inter{public void love(){System.out.println("teacher love Java!");}}//测试类public class InterfaceDemo {public static void main(String[] args) {//调用TeacherDemo中的method()方法TeacherDemo td = new TeacherDemo();//创建该接口对象：通过接口多态//Inter i = new Teacher();//匿名内部类Inter i = new Inter(){public void love(){System.out.println("teacher love Java!");}};td.method(i);}}

返回值：返回值如果是接口类型，需要返回的是该接口子实现类对象（通过子实现类进行实例化！）

//定义接口interface Inter2{public abstract void love();}//定义一个返回值是接口的类class TeacherDemo2{//如果一个方法的返回值是接口类型，需要返回该接口对应的子实现类的对象public Inter2 method(){Inter2 i = new Teacher2();return i;//return new Teacher2();}}//接口的子实现类class Teacher2 implements Inter2{public void love(){System.out.println("teacher love Java!");}}//测试类public class ReturnInterface {public static void main(String[] args) {TeacherDemo2 td = new TeacherDemo2();Inter2 inter2 = td.method();inter2.love();}}

二.内部类

1.概念：在一个类中定义另一个类，称为内部类。

eg:在类A中定义一个类B，那么类B是类A的内部类，同理，类A就是类B的外部类。内部类是直接可以访问外部类的成员，包括私有。外部类要访问内部类的成员，必须通过创建内部类的对象访问该内部类的成员。

class Outer{//外部类的成员变量public int num = 10;private int num1 = 20;//内部类class Inner{//内部类的成员方法public void show(){//内部类可以直接访问外部类的成员，包括私有System.out.println("num = "+num);System.out.println("num1 = "+num1);}}//外部类的成员方法public void method(){//外部类不能直接访问内部类，必须创建内部类的对象Inner i = new Inner();i.show();}}//测试类public class InnerDemo {public static void main(String[] args) {Outer o = new Outer();o.method();}}

2.内部类的分类：成员内部类、局部内部类

package day_09_10_24;//外部类class Outer{//外部类的成员变量public int num = 12;//成员内部类class Inner{}//外部类的成员方法public void method(){//局部内部类class Inner2{}}}//测试类public class InnerClass {public static void main(String[] args) {}}

1）成员内部类：在外部类的成员位置，测试类中需要访问成员内部类中的成员方法：外部类名.内部类名 对象名 = 外部类对象.内部类对象；

package day_09_10_24;//外部类class Outer3{//定义外部类的变量public int num = 10;//成员内部类（非静态成员内部类）class Inner3{//内部类的成员方法（非静态的成员方法）public void show(){System.out.println("num = "+num);}}//外部类的成员方法public void method(){}}//测试类public class MemberInner {public static void main(String[] args) {/** * 需求：访问Inner3成员内部类中的show()方法 * 外部类名.内部类名 对象名 = 外部类对象.内部类对象; */Outer3.Inner3 oi = new Outer3().new Inner3();oi.show();}}

成员内部类修饰符：

private :为了保证数的安全性，外部类访问成员内部类方法：外部类

package day_09_10_24;class Body{public String heart;//成员内部类private class Inner{public void operator(){System.out.println("医生做手术");}}//成员方法public void behave(){boolean flag = true;if(flag){Inner i = new Inner();i.operator();}}}public class MemberInnerPrivate {public static void main(String[] args) {/** * 成员内部类被private修饰，直接创建外部类对象，通过外部类成员方法间接访问内部类成员方法 * */Body b = new Body();b.behave();}}

static：为了方遍调用，如果成员内部类被static修饰，那么要访问外部类的成员变量，这个变量必须被static修饰

 静态的成员内部类访问该类中的成员方法：

外部类名.内部类名  对象名 = new 外部类名.内部类名（）；

package day_09_10_24;class Outer4{//外部类的成员变量public static int num1 = 10;public static int num2 = 20;/** *对于静态的成员内部类，无论其中的方法是静态的还是非静态的，要访问外部类的成员变量，该变量必须被static修饰  **/public static class Inner4{//静态的内部成员方法public static void show(){System.out.println("num1 = "+num1);System.out.println("num2 = "+num2);}//非静态的内部类的成员方法public  void show2(){System.out.println("num1 = "+num1);System.out.println("num2 = "+num2);}}}//测试类public class MemberInnerStatic {public static void main(String[] args) {/** * 需求：要访问静态成员内部类Inner4里面的show(),show2()方法 * 外部类名.内部类名 对象名 = new 外部类名.内部类名(); * */Outer4.Inner4 oi = new Outer4.Inner4();oi.show2();oi.show();  //静态方法System.out.println("------------");//show的另一种访问方法；Outer4.Inner4.show();  //静态方法可以直接通过类名方法}}

2）局部内部类：定义在外局部类的局部位置

局部内部类访问该类中的成员方法：直接创建外部类的对象，通过外部类对象访问外部类方法

结论：无论是局部内部类还是成员内部类（非静态的）都可以直接访问外部类的成员，包括私有成员

package day_09_10_24;class Outer5{public int num1 = 10;private int num2 = 20;//外部类的成员方法public void method(){//局部变量final int num3 = 20;  //自定义常量//局部内部类class Inner5{public void show(){System.out.println("num1 = "+num1);System.out.println("num2 = "+num2);//局部内部类中访问局部变量System.out.println("num3 = "+num3);//jdk1.7才会有这个错误!jdk1.8--->封装好了,所以不会出现错误!}}Inner5 i = new Inner5();i.show();}}//测试类public class InnerLocal {public static void main(String[] args) {//对于局部内部类访问该类中的成员方法：创建外部类对象，使用外部类对象调用外部类的成员方法Outer5 o = new Outer5();o.method();}}

面试题：局部内部类访问局部变量会出现问题？（比如上例中的局部变量num3）

当前局部变量会报错，必须用final修饰；

为什么用final修饰？

由于局部变量是随着方法调用而生产的，随着方法的调用完毕消失，而现在局部位置有一个局部内部类，它要在自己的成员方法位置访问当前的局部变量，必须把变量变成一个常量（需要用final:自定义常量），这样的一个变量的值是永远固定的。

三.匿名内部类

内部类的简化版格式

前提条件：必须存在一个接口或者一个类（可以是具体类，也可以是一个抽象类）

格式：

new 接口或者类名{

方法重写；

}

匿名内部类的实质：继承了该类（抽象类）或者是实现了该接口的子类对象

package day_09_10_24;//定义一个接口interface Inter9{//抽象功能public abstract void show();public abstract void show2();}//外部类class Outer6{//成员方法public void method(){/*//当接口中只有一个方法的情况new Inter9(){public void show(){System.out.println("匿名内部类");}}.show();}*///匿名内部类.接口中有两个方法的时候Inter9 i = new Inter9(){//方法重写public void show(){System.out.println("show匿名内部类");}public void show2(){System.out.println("show2匿名内部类");}};i.show();i.show2();}}public class InnerDemo2 {public static void main(String[] args) {Outer6 o = new Outer6();o.method();}}

package day_09_10_24;/** * 匿名内部类在开发中的使用 * */interface Inter3{public abstract void study();}class StudentDemo1{public void method(Inter3 i){  //形式参数是接口i.study();}}//方式1：class Adess implements Inter3{public void study(){System.out.println("好好学习，天天向上。。。");}}public class OuterTest {public static void main(String[] args) {//调用StudentDemo1中的method()方法StudentDemo1 sd = new StudentDemo1();Inter3 i = new Adess();sd.method(i);//i.study();System.out.println("---------------");//方式2：匿名内部类StudentDemo1 sd2 = new StudentDemo1();sd2.method(new Inter3(){//方法重写public void study(){System.out.println("好好学习，天天向上。。。");}});}}

package day_09_10_24;/** * 匿名内部类面试题：按照要求，补齐代码interface Inter { void show(); }class Outer { //补齐代码 }public class InterTest {public static void main(String[] args) {  Outer.method().show();  }}要求在控制台输出”HelloWorld” 分析： * 当前method()能直接被类名调用---->method()方法是一个静态方法static  * Outer.method().show()---->Outer.method()返回的是一个对象，拿对象调用show()方法 * 接口只有一个show()方法，需要重写show()方法 * *///接口interface Inter5{public abstract void show(); }//外部类class Outer8{//补齐代码public static Inter5 method(){//返回值是一个接口return new Inter5(){//重写show方法public void show(){System.out.println("HelloWorld!");}};}}//测试类public class InterTest {public static void main(String[] args) {Outer8.method().show();}}

package day_09_10_24;/** *  * 看程序 * 面试题：要求请填空分别输出30，20，10。外部类和内部类没有继承关系! * */class Outer7 {public int num = 10;class Inner7 {public int num = 20;public void show() {int num = 30;System.out.println(num);  //30System.out.println(this.num); //20;this指当前对象System.out.println(new Outer7().num);//10;要访问外部类的成员变量:匿名对象 :new 外部类名().成员变量//外部类的this限定System.out.println(Outer7.this.num);//10}}}//测试类public class InterclassTest {public static void main(String[] args) {Outer7.Inner7 oi = new Outer7().new Inner7();oi.show();}}