08_Java基础_内部类_静态导入_增强for循环

------- android培训、java培训、.net培训、 IOS培训 期待与您交流！
-------

内部类

什么叫内部类

在类的内部定义的类就叫内部类。

什么情况下使用内部类

当类A中的内容（包括内部类）要被B直接访问时，且A还要创建B的对象访问B的内容时，可以将B定义到A的内部，作为一个内部类。

其中要注意的是：

内部类可以直接访问外部类的所有成员，私有成员也可以。

外部类想要访问内部类的成员，必须创建内部类的对象。

当描述事物时，事物的内部还有事物，这个内部的事物还在访问外部事物中的内容。

这时就将这个事物通过内部类来描述。

非静态内部类中不允许定义静态成员。仅允许在非静态内部类中定义 静态常量 static final。

如果想要在内部类中定义静态成员，必须内部类也要被静态修饰。

内部类被静态修饰后，随着Outer的加载而加载。可以把一个静态内部类理解为就是一个外部类。

内部类的定义方式如下：

class Outer//外部类。
{
private static int num = 4;
public class Inner//内部类。
{
void show()
{
System.out.println("num="+num);
}
}

static class Inner2
{
void show2()
{
System.out.println("Inner2 show2 run..."+num);
}
static void staticShow()
{
System.out.println("Inner2 staticShow run");
}
}
void method()
{
Inner in = new Inner();
in.show();
}
}

思考：为什么内部类能够直接访问外部类的成员？

那是因为内部类其实持有了外部类的引用 外部类.this

对于静态内部类不持有 外部类.this 而是直接使用 外部类名。

以下代码有助于理解：

class Outer
{
int num = 3;
class Inner
{
int num = 4;

void show()
{
int num = 5;
System.out.println("num="+num);
System.out.println("num="+this.num);
System.out.println("num="+Outer.this.num);
}
}

void method()
{
new Inner().show();
}
}

class InnerClassDemo2
{
public static void main(String[] args)
{
Outer out = new Outer();
out.method();
}
}

内部类定义的位置

内部类除了可以定义在外部类的成员位置上外，

还可以定义在外部类的局部位置上。

但是，内部类定义在局部时，不能被public static private 等成员修饰符修饰。

且，在定义在局部位置上时，内部类就只能访问被final修饰的局部变量了。

因为在编译生产的class中就可以直接操作那个最终数值了。

局部内部类对局部成员的访问演示：

class Outer
{
int  num = 3;
void method()
{
final int  x = 10;
//		final int x = 5;//局部变量。
int y = 2;
class Inner//局部内部类。不能被成员修饰符修饰。
{
void show()
{
//				System.out.println("y="+y);//在这里是不能访问y的，y的生命周期太短了。
System.out.println("x="+x);
System.out.println("inner show run........"+num);
}
}
new Inner().show();
}
}

内部类的延伸

内部类是可以继承或者实现其他的外部类或者接口的。

其实就跟普通类的定义一样，都是可以继承或者实现接口的。

以下是内部类继承其他类的实例：

abstract class AbsDemo
{
abstract void show();
}

class Outer
{
int num = 3;
private class Inner extends AbsDemo
{
//重写抽象方法show。
void show()
{
System.out.println("num="+num);
}
}

//获取内部类的对象。
public AbsDemo getObject()
{
return new Inner();
}

public void method()
{
new Inner().show();
}
}

匿名内部类

匿名内部类就是内部类的一种简化形式，

但是它的定义是有前提的：

那就是内部类必须继承父类或者实现接口。

匿名内部类说白了其实就是一个带有内容的子类对象。

以下是匿名内部类的定义示例：

abstract class AbsDemo
{
abstract void show();
}

class Outer
{
int num = 3;
public void method()
{

new AbsDemo()//这就是一个AbsDemo的子类对象。只不过这个对象有点胖！这是一个带着内容的子类对象。
//这种写法一个称呼：匿名内部类。
{
//重写抽象的show方法。
void show()
{
System.out.println("num===="+num);
}
}.show();

}
}

异常。

Java运行时期发生的问题就是异常。

Java中运行时发生的除了异常Exception还有错误Error。

异常：通常发生可以有针对性的处理方式的。

错误：通常发生后不会有针对性的处理方式。

Error的发生往往都是系统级别的问题，都是jvm所在系统发生的并反馈给jvm的。

无法针对处理，只能修正代码。

以下为代码示例：

class ExceptionDemo
{
public static void main(String[] args)
{
int[] arr = new int[1024*1024*100];//OutOfMemoryError

System.out.println(arr[0]);
System.out.println(arr[3]);//该句运行时发生了ArrayIndexOutOfBoundsException，导致程序无法继续执行。程序结束。
System.out.println("over");
}
}

内部类总结：

内部类。

内部类的由来：因为访问的特点。一个类如果直接访问另一个类中的成员，建议写内部类。

内部类出现后访问特点：

内部类可以直接访问外部类的成员，包括私有的。

外部类要访问内部类需要创建内部类的对象。

内部类在成员位置可以给成员修饰符所修饰。

public ： 格式 外部类名.内部类名 变量名 = new 外部类().new 内部类();

static ：

情况一：访问静态内部类中的非静态成员。

外部类名.内部类名 变量名 = new 外部类名.内部类名();

情况二：访问静态内部类中的静态成员。

外部类名.内部类名.静态成员;

注意事项：

非静态内部类中，不允许定义静态成员，只可以定被final修饰的static常量。

外部类的静态方法要访问内部类，需要创建内部类的对象，一定要注意，该内部类必须被静态修饰。

否则，只能通过外部类对象.内部类对象的方式访问。看以下代码演示。

class Outer
{
static class Inner1
{
}

class Inner2
{
}

public static void method()
{
//访问Inner1.
new Inner1();

//访问Inner2非静态。
new Outer().new Inner2();

}

}

非静态内部类之所以可以直接访问外部类中的成员：原因是内部类持有了 外部类名.this

局部内部类。

局部内部类一样可以直接访问我外部类中的成员。

注意：局部内部类不能直接访问局部中的变量：局部变量生命周期太短，很有可能局部变量已消失，而内部类对象还在。

局部内部类只能访问被final修饰的局部变量，因为是一个常量，值不变。

内部类是可以继承其他类和实现接口的。★★★★

如果内部类不需要对外提供，可以通过其继承的父类或者实现的接口，这种公共的类型对外提供。

匿名内部类。

原理：匿名内部列其实就是一个子类对象。

格式：new 父类or接口(){子类内容}

如果实在接收不了匿名内部类的格式，可以还原成内部类。

通常匿名内部类中的方式不要过多(少于两个)，以免降低阅读性。

静态导入

首先明白import 语句可以导入某一个类或者某一个包下的所有的类

import static 导入的是某个类中的静态方法或者某个类中的所有静态方法。

比如Math类中有一些静态方法，我们在写程序的过程中想要用其中的某个静态方法时
都是这样：Math.abs();等等。
当我们使用静态导入导入Math中的静态方法之后，在再次使用abs方法的时候可以不再写Math.

导入方法如下：
import static java.lang.Math.*; //导入Math类中所有的静态方法。
import static java.lang.Math.abs;//导入Math类中的abs静态方法。

要注意的是静态导入只有1.5之后才有，如果使用1.4以及之前的编译器编译就会出现问题。

增强for循环

增强for循环的作用是对集合进行迭代。如下是对数组中数据求和的代码：

int sum(int[] arr){

int sum = 0;

for(int i:arr){

sum += i;

}

return sum;

}

其中要注意的是，被迭代的集合必须实现了iterable接口。

------- android培训、java培训、.net培训、IOS培训
期待与您交流！ -------