java-内部类

内部类：

嵌套在另一个类中定义的类就是内部类。包含内部类的类就是外部类

内部类声明

class outer{    //外部类
    int outer_x = 100;    //外部类成员
    class inner{    //内部类
        void display(){
            System.out.println("display : " + outer_x);    //内部类成员
        }
    }
}    

静态方法（全局方法）：

既没有访问this的属性，也没有访问this 的方法，是一种特殊的方法

java语言里，静态方法用static修饰

静态方法里不能访问this，它跟类没有关系

成员式内部类——对象成员内部类

内部类中访问外部类：

在内部类中访问外部类，就像同一个类中成员互相访问一样，是没有限制的，包括声明为private的成员

class outer{
    int i = 100;
    class inner{
        public void method(){
            System.out.println("外部类中的成员变量：   " + i);
           }
        }
}
public class HelloWorld {
	public static void main(String[] args) {
        outer.inner in = new outer().new inner();//可以拆分成两条语句
	//outer ot = new outer();
	//outer.inner in = ot.new inner();
	    in.method();
	}
}

method方法可以直接访问外部类成员变量i

外部类中访问内部类：

在外部类中访问内部类是比较容易的，只要把内部类看成是一个类，然后创建该类的对象，使用对象来调用内部类的成员即可

class outer{
	int j;
	class inner{
		int i = 30;
	}
	public void method()
	{
		inner in = new inner();
		int j = in.i;
		System.out.print("内部类变量的值： " + j);
	}	
}
public class HelloWorld {
	public static void main(String[] args) {
        outer ot = new outer();
		ot.method()；
	}
}

内部类本身仍是一个类，所以在它内部定义了变量i。如果想要访问变量i，就要先产生一个内部类的对象in，通过对象来访问成员变量i

在外部类外访问内部类：

先创建一个外部类的对象，然后让该外部类对象调用创建一个内部类对象

class outer{
	class inner{
		int i = 50;
		int j = 100;
	}
}
public class HelloWorld {
	public static void main(String[] args) {
        outer.inner in1 = new outer().new inner();    //两种基本语法
		outer ot = new outer();
		outer.inner in2 = ot.new inner();
		System.out.println("内部类中的变量i: " + in1.i);
		System.out.println("内部类中的变量j: " + in2.j);
	
	}
}

在外部类外访问内部类时，是不能够直接创建内部类对象的，因为内部类只是外部类的一个成员，所以，要想创建内部类对象，首先要创建外部类对象，然后以外部类对象为标识来创建内部类对象

成员时内部类——静态内部类

创建静态内部类

class outer{
    static class inner{    //静态内部类
        //内部类成员
    }
//外部类成员
}

对于静态内部类来说，它只能访问其封装类中的静态成员

在外部类中访问静态内部类

与非静态内部类一样

class outer{
	static class inner{
		int i = 50;
		static int k = 100;
	}
	public void method(){
		inner in = new inner();
		int j = in.i;
		System.out.println("静态内部类的实例变量值为：" + j);
		System.out.println("静态内部类的静态变量值为：" + inner.k);
	}
}
public class HelloWorld {
	public static void main(String[] args) {
	outer ot = new outer();
		ot.method();
	}
}

在外部类外访问静态内部类

class outer{
	static class inner{
		int i = 50;
		static int j = 100;
	}
}
public class HelloWorld {
	public static void main(String[] args) {
        outer.inner in = new outer.inner();
		System.out.println("静态内部类的实例变量i： " + in.i );
		System.out.println("静态内部类的静态变量j： " + outer.inner.j);
	}
}

访问静态内部类的静态成员时时不需要创建内部类对象的，但是在访问静态内部类的非静态成员时仍需要创建内部类对象

局部内部类：

创建局部内部类

class outer{
    public void method(){
        class inter{    //局部内部类
            int i = 50;    //局部内部类的成员变量
        }
    inner n = new inner();
    System.out.println("局部内部类的变量为： " + n.i);
}
public class HelloWorld {
	public static void main(String[] args) {
		outer ot = new outer();    //创建外部类对象
		ot.method();    //调用内部类成员
	}
}

在局部内部类中访问外部类成员变量

class outer{
	int i = 30;
	public void method() {
		class inner{    //定义局部内部类
			public void innermethod(){
				System.out.printf("外部类成员变量i:  " + i);
			}
		}
		inner n = new inner();
		n.innermethod();
	}
}

public class HelloWorld {
	public static void main(String[] args) {
        outer ot = new outer();    //创建外部类对象
		ot.method();    //调用内部类中成员
	}
}

匿名内部类：

匿名内部类总是用来扩展一个现有的类，或者实现一个接口

匿名内部类是没有名字的，在创建匿名内部类时要同事创建匿名内部类的对象

new innerfather()
//innerfather是匿名内部类继承的父类的类名或实现的接口名，用new来创建匿名内部类的对象
{
    //匿名内部类
};

class innerfather
{
	public void method()	//父类中的方法
	{
		System.out.println("内部类父类方法");
	}
}
public class HelloWorld {
	public static void main(String[] args) {
	        innerfather nf = new innerfather() {    
            //创建匿名内部类，实例化对象是innerfather的子类对象
			public void method()
			{
				System.out.println("匿名内部类的方法");
			}
		};
		nf.method();    //调用匿名内部类的方法
	}
}

扩展：

Math类：

abs（a）a的绝对值

pow(a,b)  a的b次幂

sqrt(a)  a的平方根

roud（a） 四舍五入

sin/cos/tan

调用：

类名+方法名

Math.sqrt(4);