JAVA函数传参与内部类

JAVA函数调用与内部类

一.函数调用

1函数传参

1)类名作为形式参数

如果方法的参数是一个类，则需要传该类的对象

public class A{
}
public void method(A a)
public static void main(String[] args){
	A a = new A();
	method(a);//需要传该类的对象
}

2)抽象类名作为形式参数

如果方法的参数是一个抽象类，则需要传该抽象类的子类的对象

public abstract class A{
}
public class B extends A{
}
public void method(A a)
public static void main(String[] args){
	B b = new B();
	method(b);//需要传该抽象类的子类的对象
}

3)接口名作为形式参数

如果方法的参数是一个接口，则需要传该接口的子类的对象

public interface  A{
}
public class B implements A{
}
public void method(A a)
public static void main(String[] args){
	B b = new B();
	method(b);//需要传该接口的子类的对象
}

2函数返回值

1)类名作为返回值类型

如果方法的返回值是一个类，则需要返回该类的对象

public class A{
}
public A method(){
	A a = new A();
	return a;//返回该类的对象
}
public static void main(String[] args){
	A a =method();
}

2)抽象类名作为返回值类型

如果方法的返回值是一个抽象类，则需要返回该抽象类的子类的对象

public abstract class A{
}
public class B extends A{
}
public static A method(){
	B a = new B();
	return b;//返回该抽象类的子类对象
}
public static void main(String[] args){
	B b =method();
}

3)接口名作为返回值类型

如果方法的返回值是一个接口，则需要返回该接口的子类的对象

public interface A{
}
public class B implements A{
}
public static A method(){
	B a = new B();
	return b;//返回该接口的子类的对象
}
public static void main(String[] args){
	B b =method();
}

二.修饰符的使用

1)修饰符

权限修饰符：private，默认的，protected，public
状态修饰符：static，final
抽象修饰符：abstract

2修饰类的修饰符

权限修饰符：默认修饰符，public
状态修饰符：final (表示该类不能被继承)
抽象修饰符：abstract (表示该类不能实例化)

3)修饰成员变量的修饰符

权限修饰符：private，默认的，protected，public
状态修饰符：static(表示该变量为静态)，final(表示该变量不能修改)

4)修饰构造方法

权限修饰符：private(则该类不能实例化)，默认的，protected，public

5)修饰成员方法

权限修饰符：private，默认的，protected，public
状态修饰符：static（静态方法，不需要实例化可以调用），final(表示该方法不能被重写）
抽象修饰符：abstract（抽象类）

6)组合规则

成员变量：public static final
成员方法：public static
public abstract
public final

三.内部类

1.什么是内部类

把类定义在其他类的内部，这个类就被称为内部类。
将类A 定义到B类当中 我们称A为内部类,B 我们可以叫外部类

public class B{  //外部类
	public class A{   //内部类
	}
}

2.内部类的特点

1内部类可以直接访问外部类的成员，包括私有。
2外部类要访问内部类的成员，必须创建对象。

public class Out{
	private int a;
	public class In{
		public int b=a;//可以直接访问内部类的私有变量
	}
	In in =new In();//在外部类中实例化内部类
}
public class text{
	public static void main(String[] args){
		 Out.In in=new Out().new In();//在外部类之外实例化内部类
	}
}

3.内部类分类

1)成员内部类

成员内部类为在成员位置定义的类。
上边所举的例子就是成员内部类。
内部类被private 修饰后,外界不能创建内部类对象，但是在外部类中还可以创建内部类对象。

public class Out{
	private class In{
	}
	In in =new In();//外部类还可以访问内部类
}
public class text{
	public static void main(String[] args){
		 //Out.In in=new Out().new In();   外界不能再访问内部类
	}
}

静态内部类只能访问外部类的静态成员，而外界访问静态内部类的格式为
外部类名.内部类名 对象名 = new 外部类名.内部类名();

public class Out{
	ptivate int a=5;
	public static int b=3; 
	public static  class In{
		//int a=Out.this.a;静态内部类只能访问外部类的静态成员
		int b= Out.this.b;   //内部类通过这种形式来访问外部类的同名变量。
	}
}
public class text{
	public static void main(String[] args){
		 Out.In in=new Out.new In();   //创建静态内部类实例的方法。
	}
}

2）局部内部类

局部内部类为在局部位置定义的类。
外界无法创建局部内部类的对象。

public class Out{
	public void method(){
		public class In{
		}
	}
}
public static void main(){
	Out o = new Out();
	o.method();
}

局部内部类访问局部变量必须用final修饰

public class Out {
    public void method() {
        final int num = 20;//被局部内部类访问，需要加上final修饰符。
        class In {
            public void show() {
                System.out.println(num);
            }
        }
    }
}

因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。

3）匿名内部类

匿名内部类是局部内部类的简写方式。
匿名内部类本质是一个对象,它是实现了该接口或继承了该抽象类的子类对象。

匿名内部类的语法

public abstract class Animal {
    public abstract void show();
 }
    public class MyDemo3 {
    public static void main(String[] args) {
        new Animal() {
            @Override
            public void show() {	//new Animal.show();
                System.out.println("我重写了show方法");
            }
        }.show();
    	testMethod(new Animal() {	//testMethod(new Animal());
           @Override
           public void show() {
               System.out.println("我重写了show方法22222");
           }
       });
    private static void testMethod(Animal an) {
        an.show();
    }
}
}