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

一.返回值

1.常量

2.引用
(1)具体类
返回该类的具体对象
代码示例

class Demo{    //成员方法    public float sum(float a,float b){        return  (a + b) ;    }}//定义一个类class Student{    public void show(){        System.out.println("好好学习,天天向上...");    }}//class StudentDemo{//  public void method(Student s){//形式参数是一个引用类型,那么需要该类对象Student s = new Student() ;//      s.show() ;//  }//}class StudentDemo{    public Student method(){//如果方法的返回值是一个具体的类,那么需要该类对象        /*Student s = new Student() ;        return s ;*/        return new Student() ;    }}//测试类public class StudentTest {    public static void main(String[] args) {        //两个实际参数        /*int a = 10 ;        int b = 20 ;*/        float a = 10.0F;        float b = 12.34F;        //需求:需要调用sum来进行求和        Demo d = new Demo() ;        float result = d.sum(a, b) ;        System.out.println("result:"+result);        System.out.println("------------------------");        //需求:需要调用StudentDemo这个类中method()方法        //需要创建StudentDemo这个类的对象//      StudentDemo sd = new StudentDemo() ;//      //创建Student类的对象//      Student s = new Student() ;////        sd.method(s) ;//当前s变量不可用//      sd.method(s) ;//s就代表Student类的对象,把空间地址值作为参数传递        //返回值是具体的类:        //创建StudentDemo类对象        StudentDemo sd = new StudentDemo() ;        Student s = sd.method() ;        s.show();    }}

(2)抽象类
返回抽象类的子类对象(匿名类的方式)
代码示例

abstract class Person2{    public abstract void show() ;}//定义PersonDemo2类class PersonDemo2{    public Person2 method(){ // 如果一个方法的返回值是一个抽象类,需要的返回是该抽象类的子类对象        /*Person2 p = new Teacher() ;        return p ;*/        return new Teacher() ;//Person2 p = new Teacher() ;    }}//抽象类的子类class Teacher extends Person2{    @Override    public void show() {        System.out.println("老师爱高圆圆,爱生活...");    }}//测试类public class PersonTest2 {    public static void main(String[] args) {        //需求:要调用PersonDemo2这个类中的method()方法        PersonDemo2 pd = new PersonDemo2() ;        Person2 p = pd.method() ;//pd.method();return new Teacher() ----->Person2 p = new Teacher() ;        p.show() ;        System.out.println("----------------");        //链式编程        Person2 p2 = new PersonDemo2().method() ;//链式编程        p2.show() ;    }}

(3)接口
返回接口的子实现类(匿名内部类的方式)
代码示例

class TeacherDemo2{ //后面反射机制:--->javac TeacherDemo2.java---->   TeacherDemo2.class(ClassLoder:类加载器)    //成员方法    public Love method(){ //如果一个方法的返回值是引用类型:接口类型        需要的是该接口对应的子实现类的对象        //由于返回值是是一个接口类型//      Love l = new Teacher2() ;//接口多态//      return  l ;        return new Teacher2() ;    }}//定义接口的子实现类class Teacher2 implements Love{    @Override    public void love() {        System.out.println("老师讲解javaSE......");    }}//测试类public class TeacherTest2 {    public static void main(String[] args){        //需求:需要调用TeacherDemo2中的method()        TeacherDemo2 td = new TeacherDemo2() ;        //使用对象名调用功能        Love l = td.method() ;//Love l = new Teacher2(); 实质就是一个接口多态        l.love() ;    }}

二.形式参数

1.常量
形参的改变不影响实际参数
2.引用
(1)具体类

需要该类的具体对象
代码示例

class Demo{    //成员方法    public float sum(float a,float b){        return  (a + b) ;    }}//定义一个类class Student{    public void show(){        System.out.println("好好学习,天天向上...");    }}//class StudentDemo{//  public void method(Student s){//形式参数是一个引用类型,那么需要该类对象Student s = new Student() ;//      s.show() ;//  }//}class StudentDemo{    public Student method(){//如果方法的返回值是一个具体的类,那么需要该类对象        /*Student s = new Student() ;        return s ;*/        return new Student() ;    }}//测试类public class StudentTest {    public static void main(String[] args) {        //两个实际参数        /*int a = 10 ;        int b = 20 ;*/        float a = 10.0F;        float b = 12.34F;        //需求:需要调用sum来进行求和        Demo d = new Demo() ;        float result = d.sum(a, b) ;        System.out.println("result:"+result);        System.out.println("------------------------");        //需求:需要调用StudentDemo这个类中method()方法        //需要创建StudentDemo这个类的对象//      StudentDemo sd = new StudentDemo() ;//      //创建Student类的对象//      Student s = new Student() ;////        sd.method(s) ;//当前s变量不可用//      sd.method(s) ;//s就代表Student类的对象,把空间地址值作为参数传递        //返回值是具体的类:        //创建StudentDemo类对象        StudentDemo sd = new StudentDemo() ;        Student s = sd.method() ;        s.show();    }}

(2)抽象类
需要该类的子类
代码示例

abstract class Person{    public abstract void study() ;}//定义一个PersonDemo类class PersonDemo{    //成员方法    public void method(Person p){//Person p = new Perosn();//错误的:抽象类不能实例化---->抽象类的多态:Person p = new Student2() ;        p.study() ;    }}//自定义一个抽象的子类来进行Person的实例化class Student2 extends Person{    @Override    public void study() {        System.out.println("good good study ,day day up!");    }}//测试类public class PersonTest {    public static void main(String[] args) {        //需求:调用PersonDemo类中method()方法        //创建PersonDemo类的对象//      PersonDemo pd = new PersonDemo() ;////        pd.method(p) ;//      //需要使用抽象类多态来实例化//      Person  p = new Student2() ;//      pd.method(p) ;        //链式编程:        new PersonDemo().method(new Student2()) ;    }}

(3)接口
需要该类的子实现类
代码示例

//定义一个接口interface Inter{    public abstract void love() ;}//定义一个类class TeacherDemo{    public void method(Inter i){//接口不能实例化:  如果一个方法的形式参数是一个接口,那么需要创建该接口的子实现类对象        i.love() ;    }}//由于接口不能实例化,需要定义接口的子实现类class Student3 implements Inter{    @Override    public void love() {        System.out.println("学生爱学习,爱java...");    }}//测试类public class TeacherTest {    public static void main(String[] args) {        //需求:需要调用TeacherDemo类中的method()方法        //创建该类对象        TeacherDemo td = new TeacherDemo() ;        //创建该接口对象:通过接口多态        Inter i = new Student3() ; //接口多态    /*  Inter i = new Inter() { //匿名内部类             @Override            public void love() {                System.out.println("学生爱学习,爱java...");            }        };*/        td.method(i) ;        System.out.println("----------------");        //匿名内部类:        Inter i2 = new Inter() {            @Override            public void love() {                System.out.println("学生爱学习,爱java...");            }        };        i2.love();    }}

三.内部类

内部类:特点 可以直接访问外部类的成员,包括私有
1.成员内部类
在一个类的成员位置定义一个类
成员内部类访问它自己类中的成员方法:
外部类名.内部类名 对象名 = 外部类对象.内部类对象;
静态的成员内部类要访问它自己的类中的成员方法
静态的成员内部类要访问外部类的成员,该成员需要静态修饰
外部类名.内部类名 对象名 = new 外部类名.内部类名() ;

class Outer4{    //外部类的两个成员变量    public  static int num = 10 ;    public static int num2 = 20 ;    /**     * 结论:     * 对于静态的成员内部类来说,无论静态成员内部类中的成员方法是静态还是非静态的,要访问外部类的成员变量,该变量必须被static修饰     * */    //定义一个静态的成员内部类    public static class Inner4{        //非静态的内部类的成员方法        public void show(){            System.out.println(num);            System.out.println(num2);        }        //静态的内部类的成员方法        public static void show2(){            System.out.println(num);            System.out.println(num2);        }    }}//测试类public class InnerDemo4 {    public static void main(String[] args) {        //需求:要访问静态成员内部类Inner4里面的show(),show2()方法        //外部类名.内部类  对象名 =外部类对象.内部类对象;//      Outer4.Inner4 oi = new Outer4().new Inner4() ;//      oi.show() ;        //静态的成员内部类访问该类中的成员方法:        //格式:外部类名.内部类名 对象名 = new 外部类名.内部类名() ;        Outer4.Inner4 oi = new Outer4.Inner4() ;        oi.show() ;        oi.show2() ;//静态方法        System.out.println("--------------");        //show2()还有另外一种访问方式:        Outer4.Inner4.show2() ;    }}

2.局部内部类
在一个类的局部位置定义一个类
局部内部类的成员变量应该被finial修饰(如果修饰jdk1.70会报错 jdk1.80不会—已经封装好了)

//外部类class Outer5{    //外部类的成员变量//  public int num = 100 ;    private int num = 100 ;    //外部类的成员方法    public void method(){        //局部变量         final int num2 = 200 ; //自定义常量(细节问题)        //局部位置        class Inner5{            //局部内部类的成员方法            public void show(){                System.out.println(num);                //局部内部类中访问局部变量                System.out.println(num2); //jdk1.7才会有这个错误!      jdk1.8---->封装好了,所以不会出现错误!            }        }        Inner5 i = new Inner5() ;        i.show() ;    }}//测试类public class InnerDemo5 {    public static void main(String[] args) {        //对于局部内部类访问具该类的成员方法:创建外部类对象 使用外部类对象调用外部类的成员方法        Outer5 o = new Outer5() ;        o.method();    }}

3.匿名内部类
* 是内部类的简化版格式
* 前提条件:
* 必须存在一个接口或者是一个类(可以是具体类,也可以是一个抽象类)
*
* 书写的格式:
* new 接口名或者类名(){
* 方法重写;
* }
*
*
* 匿名内部类的实质:
* 继承了该类(抽象类)或者是实现了该接口的子类对象!
* */

//定义一个接口interface Inter{    //抽象功能    public abstract void show() ;    public abstract void show2() ;}//外部类class Outer6{    //成员方法    public void method(){        //当接口中有一个方法的时候//      new Inter(){////          @Override//          public void show() {//              System.out.println("show");//          }//          //      }.show() ;        //当接口中有两个方法的时候        /*new Inter(){            @Override            public void show() {                System.out.println("show");            }            @Override            public void show2() {                System.out.println("show2");            }        }.show() ;        new Inter(){            @Override            public void show() {                System.out.println("show");            }            @Override            public void show2() {                System.out.println("show2");            }        }.show2();*/        //使用接口名 对象名 = 匿名内部类的格式: new 接口名(){                        //方法重写();        //}//      Inter i2 = new Inter() ;        Inter i = new Inter(){                  @Override            public void show() {                System.out.println("show");            }            @Override            public void show2() {                System.out.println("show2");            }        };        //使用对象名调用        i.show();        i.show2() ;    }}//测试类public class InnerDemo6 {    public static void main(String[] args) {        Outer6 o = new Outer6() ;        o.method() ;    }}