Embed Size (px)
DESCRIPTION
第 8 章 继承、抽象类和接口 包、内部类. 8.4 内部类与匿名类. 内部类 (Inner Class) 是定义在 类中的类 内部类 : 将逻辑上相关的类放到一起 匿名类 (Anonymous Class): 一种特殊的内部类. 8.4.1 内部类. 内部类也称“嵌套类” , 包含内部类的类称为“外部类” 内部类看作是外部类的一个成员，所以称为“成员类”. 1 内部类的定义方法与其它类相同 2 内部类可以被声明为： private , protected 3 内部类存取外部类的 所有成员 ( 含私有 ) 。 - PowerPoint PPT Presentation
Citation preview
1
第 8 章 继承、抽象类和接口
包、内部类
2
8.4 内部类与匿名类
内部类 (Inner Class) 是定义在类中的类内部类 : 将逻辑上相关的类放到一起匿名类 (Anonymous Class): 一种特殊的内部类
3
8.4.1 内部类内部类也称“嵌套类” , 包含内部类的类称为“外部类”内部类看作是外部类的一个成员，所以称为“成员类”
1 内部类的定义方法与其它类相同2 内部类可以被声明为： private , protected3 内部类存取外部类的所有成员 ( 含私有 ) 。 外部类通过内部类对象访问内部类的成员 ( 含私有 )4 内部类通过 外部类名 .this. 成员 访问外部类的同名成员
5 在其他类中使用内部类：外部类 . 内部类 ; 建对象：外部对象 .new 内部类名 ( )
4
6 非静态内部类，不能定义静态成员 ( 类成员 )。
静态内部类可以定义静态成员。7 内部静态类中只能访问外部类的静态成员。 8 static 方法中不能访问非 static 成员。 也不能 new 创建非 static 的内部类。
5
class Outer { // 内部类 private int size ; public class Inner { private int x=1; public void doStuff(){ size ++; } } public void testInner(){ Inner i=new Inner(); i.doStuff(); i.x++; System.out.println( size); } }public class demo{ public static void main(String args[]){ Outer o = new Outer(); o.testInner(); }}
内部类访问外部类的成员
外部类使用内部类
6
o
i
sizetestInner()
Outer对象
xdoStuff(); Inner
对象outer.this
7
class Outer { // 内部类 private int size ;
public class Inner { private int size =3;
public void doStuff(){ int size ; size ++; this.size ++; outer.this.size ++; System.out.println(size); System.out.println(this.size)
; System.out.println( Outer.this.size); } }
public void testInner(){ Inner i=new Inner(); i.doStuff(5); } public static void main( String args[]){ Outer o = new Outer(); o.testInner(); } }
8
class Outer { // 其他类中建立内部类对象 private int size=1 ; public class Inner {
private int x; inner(int a){ x = i; }
public void doStuff(){ size ++; } } public void testInner(){
Inner i = new Inner(2); i.doStuff(); System.out.println( size); } }public class Demo { public static void main(String args[]){ Outer oo = new Outer(); oo.testInner(); Outer.Inner o_i1 = oo.new Inner() ; o_i1.doStuff(); Outer.Inner o_i2 = new Outer().new Inner() ; } }
9
改错：class A { // 内部类 private int x,y; A(){ x=0;y=0;} A(int i,int j) { x=i;y=j;} void show(){System.out.println( x+”,”+y); } public class B {
private int y , z=0; B(int m){ y = m;}
public void inc(){ x++; y++; A.y++;} void show(){ A.show() , System.out.print(y); }
} public void f1() { B b1 = new B(2);
z++; b1.inc(); b1.show(); }}public class innerClass { public static void main(String args[]){ A a1= new A(7,9); a1.f1(); a1.B.show(); } }
10
class A { // 静态内部类 private int x=1 ; private static int y=9; void show(){System.out.println(x +”,”+y);} static void print(){System.out.println( y);} public static class B{ B(){};
void f1(){ System.out.print(y); print();} static void f2(){ System.out.print(y); } ;
} void testB(){
B b1 = new B(); b1.f1();
B.f2(); } }
11
class A { // 静态内部类 改错 private int x=1 ; private static int y=9; public static class B{ static int z=2; B(){};
void f1(){ System.out.print(x+”,”+y);} } public class C { static int k; void f2(){System.out.print(k); } } void testB(){ B b1 = new B(); b1.f1(); C c1 = new C(); c1.f2(); } static void testC(){ B b1 = new B(); b1.f1(); C c1 = new C(); c1.f2(); } }
12
class A { // 静态内部类 改错 private int x=1 ; private static int y=9; public static class B{
void f1(){ System.out.print(y);} } void testB(){ B b1 = new B(); b1.f1(); }} public class Demo { public static void main(String args[] ){ A a1 = new A() ; A.B b2 = a1.new B(); //new A.B();
}}
13
public class Group { // 内部类与外部类的访问规则 private int age; public class Student { String name; public Student(String n,int a) { name=n; age=a; } public void output() { System.out.println(“ 姓名 :”+name+”, 年龄 :”+age); } } public void output() { Student stu=new Student(“ 刘 洋” ,24); stu.output(); } public static void main(String args[]) { Group G=new Group(); G.output(); }}
14
class app8_15 {// 静态内部类的访问 注意错误 public static void main(String args[]) { A.B a_b=new A().newB(); // 正确 A a=new A(); A.B ab=new a.new B(); Outer.Inner oi=new Outer.Inner(); // Outer.Inner oi2=Outer.new Inner(); // 错误 // Outer.Inner oi3=new Outer().new Inner(); // 错误 }}class A { private int x; void m() { new B();} static void sm() { // new B() // 错误！ } class B { // 内部类 B(){x=5;} }}class Outer { static class Inner { }}
15
8.4.2 匿名内部类匿名内部类 (anonymous inner class) ：利用内部
类创建没有名称的对象，并利用它访问到类里的成员。
语法格式 1 ：（ new 父类名 (){ 方法名（参数 1 ，参数 2 ，…，参数 n ） { 方法体语句； } }） . 方法名（参数 1 ，参数 2 ，…，参数 n ）；
16
语法格式 2 ： 父类名 < 对象名 >= new 父类名 (){ 方法名（参数 1 ，参数 2 ，…，参数 n ） { 方法体语句； } }
17
• 匿名类• 1 在一个表达式内部建立没有类名的内部类• 2 无法自己定义构造方法，仅有默认构造方法• 3 匿名类一定是一个类的子类
•（ new 父类名 (){ 类体 } )
18
class A { // 匿名类演示 private int x =1; void show(){ System.out.println(x); }}
class B { public static void main( String args[]){ ( new A() { public void show(){ System.out.println("bb“+x); } } ).show(); } }
A 的无名子类:
19
abstract class A { // 匿名类演示 private int x =1; void show(){ System.out.println(x); } abstract f1();}
class B { public static void main( String args[]){ A a = new A() { void show(){ System.out.println("bb“+x); } void f1(){ System.out.println(“f1”); } } ; a.show(); a.f1(); } }
20
class A { // 匿名类 private int x ; void show(){ System.out.println(x);}}class B { static void fun( A a1){ a1.show(); }
public static void main( String args[]){ fun( new A() { public void show(){ System.out.println("aa"); } } ) ; } }
21
class A { // 匿名类 改错 private int x ; A(int i) { x = i; } void show(){ System.out.println(x); }}
class B { public static void main( String args[]){ A a = new A() { A(int k ){ super(k) ; } void show(){ System.out.println("bb“+x); } void f1(){ System.out.println(“f1”); } } ; a.show(); a.f1(); } }
22
8.5 包包 (package) ：管理类名空间。文件夹把各种文件组织在一起包把各种类组织在一起，使得程序功能清
楚、结构分明。
8.5.1 包的概念 包：区别类名空间的机制，是类的组织方式。 包：对应一个文件夹，包中还可以再有包，称为包等级。
23
8.5.2 使用 package 语句创建包package 包名 1[. 包名 2[. 包名 3]…] ；
（ 1 ）无 package 语句，则为无名包（ 2 ）有名包的创建：
package dir1 package dir1.dir2
dir 是一个文件夹，存放 .class 文件，包中的“ .”号表示子文件夹。 (3) 有名包中类的存储位置
package dir1.dir2 存储在 classpath 指定文件文件夹下的 dir1.dir2
24
8.5.3 Java 中的常用包Java 的常用包有：
java.lang 语言包java.io 输入输出流的文件包java.awt 抽象窗口工具包java.util 实用包java.applet Applet小程序包java.net 网络功能包java.sql 数据库连接包java.text 文本包
25
8.5.4 利用 import 语句引用 Java 定义的包
如果要使用 Java 包中的类，在源程序中用 import 语句导入所需要的类。
import < 包名 1>[.< 包名 2>[.< 包名 3>…] ].< 类名 >|*
如： import dir1.dir2.Myclass import dir1.*
注意： * 仅代表本包中的所有类，不代表子包中的类
26
三 设置 CLASSPATH 环境变量1 CLASSPATH 变量指明“ .class” 文件存放的位置。2 编译时： javac –d CLASSPATH 路径 Myclass.java
例如： javac –d d:\javalib myclass.java 则直接在 d:\javalib 下创建在 myclass.java 指明的
包目录，并把 Myclass.class 拷到该目录下。如： javac -d d:\javalib testA.java
自动创建 mytool 文件夹， testA.class 存在 d:\javalib\mytool testA.java 在 d:\javalib
27
包设计
package mytool; //testA.javapublic class testA{ public void show(){ System.o
ut.println(“hello”); }}
import mytool.testA;public class packageDemo{ public static void main(String args[]){
testA a1=new testA(); a1.show(); }}
1 classpath 设置为： d:\javalib
2 testA.class 存储于 d:\javalib\mytool
3 packageDemo.class
存储于 d:\javalib
4 java packageDemo
存储：d:\javalib
packageDemo.class
mytool
testA.class
28
package mytool; //testA.javapublic class testA{ public void show(){ System.out.println(“hello”); }}
public class packageDemo{ public static void main(String args[]){ mytool.testA a1=new mytool.testA(); a1.show(); }}
29
package pk1; // 改错 A.javaclass A{ int x=2; protected int y=5; void show(){ System.out.println(x+y); }}
public class packageDemo2{ //packageDemo2.java public static void main(String args[]){ A a1=new A(); a1.show(); B b1= new B(); b1.show(); }}
package pk2; //B.javaclass B extends A { int z=9; void show(){ System.out.println(x+y+z); }}
30
package pk1; public class A{ protected int x=2; protected int y=5; public void show(){ System.out.println(x+y); }}
import pk1.*;import pk2.*;public class packageDemo2{ public static void main(String args[]){ A a1=new A(); a1.show(); B b1= new B(); b1.show(); }}
package pk2; import pk1.A;public class B extends A { int z=9; public void show(){ System.out.println(x+y+z); }}
31
练习包的制作1 ） testA 类存储在 testA.java 中 package mytool; public class testA{ public void show(){ System.out.println(“TestA: hello ”); } }2) testB 类存储在 testB.java 中package mytool.tool;import mytool.testA; public class testB{ public void show(){ System.out.println(“TestB: hello ”); } }3) testC 类存储在 testC.java 中import mytool.testA;import mytool.tool.testB;public class testC{ public static void main(String args[]){ testB b1=new testB(); b1.show(); }}
1 在 Dos 下编译并运行成功。2javac 命令中 – d 参数的作用？
3 在 eclipse 中运行
32
包练习：1) 文件名 packageDemo.java 中有类：， public class packageDemo{ public static void main(String args[]){ A a1=new A(); a1.show(); B b1 = new B(); b1.show(); C c1 = new C();c1.show(); D d1 = new D();d1.show(); }2) 文件 A.java 存储在包 pk_A 中，有类： class A { private int x=3; void show(){ System.out.println(“A”+x) ;} }3) 文件 B.java 存储在包 pk_B 中，有类： class B { void show(){ System.out.println(“B”) ;} }3) 文件 C.java 存储在包 pk_C 中，有类： class A1 extends A { void show(){ System.out.println(“C” +
x) ;} }4) 文件 D.java 存储在包 pk_B.pk_B1 中，有类： class D { void show(){ System.out.println(“D”) ;} } 请完善上述程序，改正可能的错误，并调试运行。腿脚
33
package pk1; //A.java 改错 public class A{ public int x=2; protected int y=5; public void show(){ System.out.println(x+y); } }
package pk2; //B.javaimport pk1.*;public class B extends A { int z=9; public void show(){System.out.println(x+y+z); } }
import pk1.*; //Demo.java import pk2.*; public class Demo{ public static void main(String args[]){ A a1=new A(); a1.show(); B b1= new B(); b1.show(); } }
34
Java 程序组成结构如下 1 package: 0或 1 个（可有可无 ) 必须放在文件开始 2 import : 引入类的定义。 0 个或多个，必须放在所有类定义 之前 3 public class : //0 个或 1 个，文件名必须与此类名相同。 4 class : //0 个或多个 interface : //0 个或多个 程序可以有一个或多个其它类、接口（非 PUBLIC 类） 一个文件中可有多个类。
5 main 方法：main 的定义： public static void main(String args[]);位置：
如有 public 类，则一定在此类中如没有 public 类， 则可放于某一个类中。
35
8.6 Java 的垃圾回收垃圾回收 (Garbage-collection) 是 Java提供的一
种自动内存回收功能，可以让程序员减轻许多内存管理的负担，也减少程序员犯错的机会。
