黑马程序员——Java基础——继承之内部类（四）

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 内部类：

package cn.fuxi.neibulei;
/**
 * 定义:将一个类定义在另一个类的里面.里面那个类就称为内部类(内置类,嵌套类).
 * 特点:1.内部类可以直接访问外部类中的成员,包括私有成员.
 * 2.而外部类要访问内部类中的成员必须要建立内部类对象.
 * 内部类的位置:
 * 内部类定义在成员位置上,可以被private|static成员修饰符修饰.
 * 被static修饰的内部类只能访问外部类中的静态成员.
 * 如果内部类是静态的,内部类成员也是静态的,可以不用创建对象,直接调用
 * 如果内部类中定义了静态成员,该内部类也必须是静态的!
 * 为什么内部类能直接访问外部类中的成员呢?
 * 那是因为内部类持有了外部类的引用,外部类名.this.
 */
class Outer{
/*
 * 内部类的设计:
 * 分析事物时,发现该事物描述中还有事物,而且这个事物还在访问被描述事物的内容,这时候就定义内部类.
 * 
 */
private static int num = 3;
static class Inner{//内部类
static void show(){
System.out.println("Inner show run  "+num);
}
}
public void method(){
Inner in = new Inner();
in.show();
}
}

public class NeiBuLeiDemo {
public static void main(String[] args) {
/*  Outer ou = new Outer();
ou.method();
//直接访问内部类中的成员
Outer.Inner in = (new Outer()).new Inner();
in.show();
*/
//如果内部类是静态的,相当于一个外部类
Outer.Inner in = new Outer.Inner();
in.show();
Outer.Inner.show();//全静态直接调用,不要创建对象
}
}

运行结果： Inner show run  3
Inner show run  3

package cn.fuxi.neibulei;
class Outer2{
int num = 3;
class Inner2{
int num =4;
void show(){
int num = 5;
System.out.println(num);
System.out.println(this.num);
System.out.println(Outer2.this.num);
}
}
void method(){
new Inner2().show();
}
}

public class NeiBuLeiDemo2 {

public static void main(String[] args) {
Outer2 o2 = new Outer2();
o2.method();
//new Outer2().method();
}

}

运行结果: 5 4 3

package cn.fuxi.neibulei;
/*
 *内部类定义在局部位置上,也可以直接访问外部类中的成员.
 *同时也可以访问所在局部中被final修饰的局部变量. 
 */
class Outer3{
int num = 3;
void method(final int y){
final int x = 9;
class Inner{
void show(){
System.out.println("show..." + x + "," + y);
}
}
Inner in = new Inner();
in.show();
}
}

public class NeiBuLeiDemo3 {
public static void main(String[] args) {
new Outer3().method(4);

}

}

运行结果: show...9,4

package cn.fuxi.neibulei;
/**
 * 匿名内部类:
 * 定义:就是内部类的简化写法.
 * 前提:内部类可以继承或实现一个外部类或者接口.
 * 格式:new 外部类或者接口名(){覆盖类火灾接口中的代码,也可自定义内容}
 * 简单理解:就是建立一个带你内容的外部类或者接口的子类匿名对象.
 * 什么时候使用匿名内部类呢?
 * 通常使用方法是接口类型参数,并且该接口中的方法不超过三个,可以将匿名内部类作为参数传递.
 * 好处:增强阅读性.
 */
abstract class Demo{
abstract void show();
}
class Outer4{
int num = 4;
void method(){
new Demo(){//匿名内部类
void show(){
System.out.println("show...."+num);
}
}.show();
}
}
public class NeiBuLeiDemo4 {

public static void main(String[] args) {
new Outer4().method();

}

}

运行结果: show....4

package cn.fuxi.neibulei;
interface Inter{
void show1();
void show2();
}
class Outer5{
public void method(){
Inter in = new Inter(){
public void show1(){
System.out.println("Inter show1 run...");
}
public void show2(){
System.out.println("Inter show2 run...");
}
};
in.show1();
in.show2();
}
}
public class NeiBuLeiDemo5 {
public static void main(String[] args) {
Outer5 o5 = new Outer5();
o5.method();
//new Outer5().method();
}

}

运行结果: Inter show1 run...
Inter show2 run...
匿名内部类:

package cn.fuxi.neibulei;
interface Inter2{
void show1();
void show2();
}
/*
 *通常的使用场景之一:
 *当函数参数是接口类型时,而且接口中的方法不超过三个.
 *可以用匿名内部类作为实际参数经行传递. 
 */

public class NeiBeiLeiDemo6 {
public static void main(String[] args) {
show(new Inter(){
public void show1(){
System.out.println("show1 run");
}
public void show2(){
System.out.println("show2 run");
}
});
}
public static void show(Inter in){
in.show1();
in.show2();
}
}

运行结果: show1 run
show2 run
对象的初始化:

package cn.fuxi.neibulei;
class Fu7{
int num = 9;
{
System.out.println("Fu");
}
Fu7(){
super();//Object
//显示初始化
//构造代码块初始化
show();
}
void show(){
System.out.println("fu show "+ num);//被子类覆盖
}
}
class Zi7 extends Fu7{
int num = 8;
{
System.out.println("Zi");
}
Zi7(){
super();
//显示初始化
//构造代码块初始化
show();
}
void show(){
System.out.println("zi show " + num);
}
}

public class ChuShiHuaDemo {
public static void main(String[] args) {
new Zi7();

}
}

运行结果: Fu
zi show 0
Zi
zi show 8