萨满大地之盾没有了7.0:Java 类之间的调用a

来源：百度文库编辑：九乡新闻网时间：2024/05/17 04:01:47

需要了解2个概念：内部类和静态修饰符static
1）首先，用内部类是因为内部类与所在外部类有一定的关系，往往只有该外部类调用此内部类。所以没有必要专门用一个Java文件存放这个类。
2）静态都是用来修饰类的内部成员的。比如静态方法，静态成员变量，静态常量。它唯一的作用就是随着类的加载（而不是随着对象的产生）而产生，以致可以用类名+静态成员名直接获得。
这样静态内部类就可以理解了，因为这个类没有必要单独存放一个文件，它一般来说只被所在外部类使用。并且它可以直接被用外部类名+内部类名获得。

以下举例说明怎么使用：
Student类有个叫School的内部类（非静态）
Student stu = new Student();
stu.School sch = new stu.School();
sch就是School的一个对象。

假如School是内部静态类：
Student.School sch = new Student.School();
外创建内部类就是把类定义至于外围类的里面

静态方法在JVM刚加载的时候就编译过了...在程序的运行过程中随时可以调用...不需要去实例化某个对象然后再去调用...可以直接用类名去调用...不过你想一下,在JVM刚加载的进修就编译过了..也就是说它一直存在着...也就是说它一直占用这内存中的地址空间...所以说也是比较占资源的噢!

相对于静态方法而言,动态方法占的内存资源就少些...因为它是什么时候使用什么时候实例化...也就是说在不使用的时候它是不会占用资源的...相对与静态方法的缺点是它每次使用的时候都要进行实例化...也就是说比较麻烦一些了...
Java代码

public class Parcel1 {
class Destination {
private String label;
Destination(String whereTo) {
label = whereTo;
}
String readLabel() {
return label;
}
}
//在类的的函数中使用内部类,与使用普通类没多大区别
public void ship(String dest) {
Destination d = new Destination(dest);
System.out.println(d.readLabel());
}
public static void main(String[] args) {
Parcel1 p = new Parcel1();
p.ship("Tasmania");
}
}

public class Parcel1 {class Destination {private String label;Destination(String whereTo) {label = whereTo;}String readLabel() {return label;}}//在类的的函数中使用内部类,与使用普通类没多大区别public void ship(String dest) {Destination d = new Destination(dest);System.out.println(d.readLabel());}public static void main(String[] args) {Parcel1 p = new Parcel1();p.ship("Tasmania");}}

如果想从外部类的非静态方法之外的任意位置创建某个内部类的对象,必须具体地知名这个对象饿类型(OuterClassName.InnerClassName),比如
Java代码

public class Parcel2 {
class Contents {
private int i = 11;
public int value() {
return i;
}
}
public Contents contents() {
return new Contents();
}
public void ship(String dest) {
Contents c = contents();
Destination d = to(dest);
System.out.println(d.readLabel());
}
public static void main(String[] args) {
Parcel2 p = new Parcel2();
p.ship("Tasmania");
Parcel2 q = new Parcel2();
// Defining references to inner classes:
Parcel2.Contents c = q.contents();
}
}

public class Parcel2 {class Contents {private int i = 11;public int value() {return i;}}public Contents contents() {return new Contents();}public void ship(String dest) {Contents c = contents();Destination d = to(dest);System.out.println(d.readLabel());}public static void main(String[] args) {Parcel2 p = new Parcel2();p.ship("Tasmania");Parcel2 q = new Parcel2();// Defining references to inner classes:Parcel2.Contents c = q.contents();}}

外部类拥有其外围类的所有元素的访问权
如果你需要生成对外部类对象的引用,可以使用外部类的名字后面紧跟圆点和this,如下:
Java代码

public class DotThis {
void f() {
System.out.println("DotThis.f()");
}
public class Inner {
public DotThis outer() {
//通过外部类名字后面紧跟远点和this获取外部类对象 //的引用
return DotThis.this;
}
}
public Inner inner() {
return new Inner();
}
public static void main(String[] args) {
DotThis dt = new DotThis();
DotThis.Inner dti = dt.inner();
//通过获取到的外部类调用外部类中的方法
dti.outer().f();
}
}

public class DotThis {void f() {System.out.println("DotThis.f()");}public class Inner {public DotThis outer() {//通过外部类名字后面紧跟远点和this获取外部类对象//的引用return DotThis.this;}}public Inner inner() {return new Inner();}public static void main(String[] args) {DotThis dt = new DotThis();DotThis.Inner dti = dt.inner();//通过获取到的外部类调用外部类中的方法dti.outer().f();}}

如果你要在main函数中创建一个内部类对象,你必须在new表达式中提供对其他外部类对象的引用,这是需要使用.new语法,比如上例代码在main中修改创建内部类Inner对象的方法改为DotThis.Inner dti = dt.new Inner()后效果一样
在拥有外部类对象之前是不可能创建内部类对象,因为内部类对象会暗暗地连接到创建它的外部类对象上,但是如果你创建的是嵌套类(静态内部类),就不需要对外部类对象的引用

在方法的作用域内(而不是在其他类的作用域内)创建一个完整的类.这被称作局部内部类:
Java代码

public interface Destination {
String readLabel();
}

public interface Destination {String readLabel();}

Java代码

public class Parcel5 {
public Destination destination(String s) {
class PDestination implements Destination {
private String label;
private PDestination(String whereTo) {
label = whereTo;
}
public String readLabel() {
return label;
}
}
return new PDestination(s);
}
public static void main(String[] args) {
Parcel5 p = new Parcel5();
Destination d = p.destination("Tasmania");
}
}

public class Parcel5 {public Destination destination(String s) {class PDestination implements Destination {private String label;private PDestination(String whereTo) {label = whereTo;}public String readLabel() {return label;}}return new PDestination(s);}public static void main(String[] args) {Parcel5 p = new Parcel5();Destination d = p.destination("Tasmania");}}

PDestination类是destination()方法的一部分,所以在destination()之外不能访问,在return语句中的向上转型,返回的是Destination的引用,是一个基类
你也可以再同一个子目录下的任意类中对某个内部类使用类标示符PDestination,因为定义在方法内部,所以不会出现命名冲突.

在任意的作用域内嵌入一个内部类,比如在if语句的作用域内:
Java代码

public class Parcel6 {
private void internalTracking(boolean b) {
if (b) {
class TrackingSlip {
private String id;
TrackingSlip(String s) {
id = s;
}
String getSlip() {
return id;
}
}
TrackingSlip ts = new TrackingSlip("slip");
String s = ts.getSlip();
}
}
public void track() {
internalTracking(true);
}
public static void main(String[] args) {
Parcel6 p = new Parcel6();
p.track();
}
}

public class Parcel6 {private void internalTracking(boolean b) {if (b) {class TrackingSlip {private String id;TrackingSlip(String s) {id = s;}String getSlip() {return id;}}TrackingSlip ts = new TrackingSlip("slip");String s = ts.getSlip();}}public void track() {internalTracking(true);}public static void main(String[] args) {Parcel6 p = new Parcel6();p.track();}}

这并不是说该类的创建时有条件的,它其实与别的类一起编译过了,然而,在定义TrackingSlip的作用域之外,它是不可用的,除此之外,与普通的类一样

匿名内部类,一直看起来有点奇怪
Java代码

public interface Contents {
int value();
}

public interface Contents {int value();}

Java代码

public class Parcel7 {
public Contents contents() {
return new Contents() {
private int i = 11;
public int value() {
return i;
}
};
}
public static void main(String[] args) {
Parcel7 p = new Parcel7();
Contents c = p.contents();
System.out.println(c.value());
}
}

public class Parcel7 {public Contents contents() {return new Contents() {private int i = 11;public int value() {return i;}};}public static void main(String[] args) {Parcel7 p = new Parcel7();Contents c = p.contents();System.out.println(c.value());}}

将返回值的生成与表示这个返回值的类的定义结合在一起,另外这个类是匿名的, 它没有名字.其实匿名类是非匿名类,然后去实现一个接口的简化形式

如果定义一个匿名内部类,并且希望它使用一个在其外部定义的对象,那么编译器会要求其参数引用时final的
Java代码

public interface Destination {
String readLabel();
}

public interface Destination {String readLabel();}

Java代码

public class Parcel9 {
//参数dest必须定义成final的,才能在匿名内部类中使用
public Destination destination(final String dest) {
return new Destination() {
private String label = dest;
public String readLabel() {
return label;
}
};
}
public static void main(String[] args) {
Parcel9 p = new Parcel9();
Destination d = p.destination("Tasmania");
System.out.println(d.readLabel());
}
}

public class Parcel9 {//参数dest必须定义成final的,才能在匿名内部类中使用public Destination destination(final String dest) {return new Destination() {private String label = dest;public String readLabel() {return label;}};}public static void main(String[] args) {Parcel9 p = new Parcel9();Destination d = p.destination("Tasmania");System.out.println(d.readLabel());}}

匿名内部类不可能有命名构造器(因为它根本没名字),但通过实例初始化,能够达到为匿名内部类创建一个构造器的效果
Java代码

abstract class Base {
public Base(int i) {
System.out.print("Base constructor, i = " + i);
}
public abstract void f();
}
public class AnonymousConstructor {
//这里i不用声明为final,因为不会再匿名内部类被直接使用
public static Base getBase(int i) {
return new Base(i) {
{
System.out.print("Inside instance initializer");
}
public void f() {
System.out.print("In anonymous f()");
}
};
}
public static void main(String[] args) {
Base base = getBase(47);
base.f();
}
}

abstract class Base {public Base(int i) {System.out.print("Base constructor, i = " + i);}public abstract void f();}public class AnonymousConstructor {//这里i不用声明为final,因为不会再匿名内部类被直接使用public static Base getBase(int i) {return new Base(i) {{System.out.print("Inside instance initializer");}public void f() {System.out.print("In anonymous f()");}};}public static void main(String[] args) {Base base = getBase(47);base.f();}}

下面来看一段代码
Java代码

public class Parcel10 {
public Destination destination(final String dest, final float price) {
return new Destination() {
private int cost;
// 这里的if语句不能作为字段初始化的一部分来执行
{
cost = Math.round(price);
if (cost > 100)
System.out.println("Over budget!");
}
private String label = dest;
public String readLabel() {
return label;
}
};
}
public static void main(String[] args) {
Parcel10 p = new Parcel10();
Destination d = p.destination("Tasmania", 101.395F);
}
}

public class Parcel10 {public Destination destination(final String dest, final float price) {return new Destination() {private int cost;// 这里的if语句不能作为字段初始化的一部分来执行{cost = Math.round(price);if (cost > 100)System.out.println("Over budget!");}private String label = dest;public String readLabel() {return label;}};}public static void main(String[] args) {Parcel10 p = new Parcel10();Destination d = p.destination("Tasmania", 101.395F);}}

对于匿名类而言,实例初始化的实际效果就是构造器,当然它受到了限制-----不能重载实例化方法,所以你仅有一个这样的构造器
匿名内部类与正规的继承相比有些受限,因为匿名内部类既可以扩展类,也可以实现接口,但是不能两者兼备.而且如果是实现接口,也只能实现一个接口

利用匿名内部类,定义工厂方法
Java代码

interface Service {
void method1();
void method2();
}
interface ServiceFactory {
Service getService();
}
class Implementation1 implements Service {
private Implementation1() {
}
public void method1() {
System.out.println("Implementation1 method1");
}
public void method2() {
System.out.println("Implementation1 method2");
}
public static ServiceFactory factory = new ServiceFactory() {
public Service getService() {
return new Implementation1();
}
};
}
class Implementation2 implements Service {
private Implementation2() {
}
public void method1() {
System.out.println("Implementation2 method1");
}
public void method2() {
System.out.println("Implementation2 method2");
}
//利用匿名内部类的方式实现一个接口,实现工厂的方式得到当前类
public static ServiceFactory factory = new ServiceFactory() {
public Service getService() {
return new Implementation2();
}
};
}
public class Factories {
public static void serviceConsumer(ServiceFactory fact) {
Service s = fact.getService();
s.method1();
s.method2();
}
public static void main(String[] args) {
serviceConsumer(Implementation1.factory);
serviceConsumer(Implementation2.factory);
}
}

interface Service {void method1();void method2();}interface ServiceFactory {Service getService();}class Implementation1 implements Service {private Implementation1() {}public void method1() {System.out.println("Implementation1 method1");}public void method2() {System.out.println("Implementation1 method2");}public static ServiceFactory factory = new ServiceFactory() {public Service getService() {return new Implementation1();}};}class Implementation2 implements Service {private Implementation2() {}public void method1() {System.out.println("Implementation2 method1");}public void method2() {System.out.println("Implementation2 method2");}//利用匿名内部类的方式实现一个接口,实现工厂的方式得到当前类public static ServiceFactory factory = new ServiceFactory() {public Service getService() {return new Implementation2();}};}public class Factories {public static void serviceConsumer(ServiceFactory fact) {Service s = fact.getService();s.method1();s.method2();}public static void main(String[] args) {serviceConsumer(Implementation1.factory);serviceConsumer(Implementation2.factory);}}

建议:优先实用类而不是接口,如果你的设计中需要某个接口,你必须了解它,否则.不到迫不得已,不要将其放到你的设计中

如果不需要内部类对象与其外围类对象之间有联系,那么可以讲内部类声明为static.通常称为嵌套类,当内部类是static时,意味着:

[1]要创建嵌套类的对象,并不需要其外围类的对象
[2]不能从嵌套类的对象中访问非静态的外围类对象

嵌套类与普通的内部类还有一个区别:普通内部类的字段的字段与方法,只能放在类的外部层次上,所以普通的内部类不能有static数据和static字段,也不能包含嵌套类.但是在嵌套类里可以包含所有这些东西
Java代码

public class Parcel11 {
private static class ParcelContents implements Contents {
private int i = 11;
public int value() {
return i;
}
}
protected static class ParcelDestination implements Destination {
private String label;
private ParcelDestination(String whereTo) {
label = whereTo;
}
public String readLabel() {
return label;
}
// 嵌套类可以包括其他静态元素
public static void f() {
}
static int x = 10;
static class AnotherLevel {
public static void f() {
}
static int x = 10;
}
}
public static Destination destination(String s) {
return new ParcelDestination(s);
}
public static Contents contents() {
return new ParcelContents();
}
public static void main(String[] args) {
Contents c = contents();
Destination d = destination("Tasmania");
}
}

public class Parcel11 {    private static class ParcelContents implements Contents {    private int i = 11;    public int value() {    return i;    }    }    protected static class ParcelDestination implements Destination {    private String label;    private ParcelDestination(String whereTo) {    label = whereTo;    }    public String readLabel() {    return label;    }    // 嵌套类可以包括其他静态元素    public static void f() {    }    static int x = 10;    static class AnotherLevel {    public static void f() {    }    static int x = 10;    }    }    public static Destination destination(String s) {    return new ParcelDestination(s);    }    public static Contents contents() {    return new ParcelContents();    }    public static void main(String[] args) {    Contents c = contents();    Destination d = destination("Tasmania");    }    }

正常情况下,不能在接口内部放置任何代码,但嵌套类可以作为接口的一部分,你放到接口中的任何类都自动的是public和static.因为类是static,只是将嵌套类至于接口的命名空间内.你甚至可以再内部类中实现其外围接口
Java代码

public interface ClassInInterface {
void howdy();
class Test implements ClassInInterface {
public void howdy() {
System.out.println("Howdy!");
}
public static void main(String[] args) {
new Test().howdy();
}
}
}

public interface ClassInInterface {    void howdy();    class Test implements ClassInInterface {    public void howdy() {    System.out.println("Howdy!");    }    public static void main(String[] args) {    new Test().howdy();    }    }    }

以前一直不知道,嵌套类竟然可以这样用
Java代码

public class TestBed {
public void f() { System.out.println("f()"); }
public static class Tester {
public static void main(String[] args) {
TestBed t = new TestBed();
t.f();
}
}
}

public class TestBed {    public void f() { System.out.println("f()"); }    public static class Tester {    public static void main(String[] args) {    TestBed t = new TestBed();    t.f();    }    }    }

就是可以把main方法放在嵌套类中

一个内部类被嵌套多少层不重要,它能透明地访问所有它所嵌入的外围类的所有成员,如下
Java代码

class MNA {
private void f() {
}
class A {
private void g() {
}
public class B {
void h() {
//访问A对象的g方法
g();
//访问MNA对象的f方法
f();
}
}
}
}
public class MultiNestingAccess {
public static void main(String[] args) {
MNA mna = new MNA();
MNA.A mnaa = mna.new A();
MNA.A.B mnaab = mnaa.new B();
mnaab.h();
}
}

Java 类之间的调用a C#调用Java类的方法 java调用.net webservice1 java调用webservice 关于java使用jacob.jar调用word的配置问题建立Android SDK下的JNI、JAVA应用完整步骤---Android JAVA调用C++代码 JNI性能测试一—JNI调用C与Java调用java性能比较 - zgjxwl-----传说中晨雨的专栏 - CSDN博客 JNIExample：java/native相互之间调用的种种情形的例子--比较老的资料 java笔记——值调用和引用调用 android wrapper C调用java api - 示韦BadSmile的日志 - 网易博客 Java和Flash之间的战争-Java频道-中国IT实验室老生常谈之C++和C#之间互相调用 - gangyilovevc的专栏 - CSDN博客基础类的DSP/BIOS API调用 linux下编程学习----- 远程过程调用(rpc) - shake863 - Java... JNA 实现Java调用C动态链接库 JNI编程 —— 让C++和Java相互调用 .net与java 使用自定义对象通过WebService调用女人之间的秘密A [图] 女人之间的秘密 [图]a java字符串的各种编码转换类读取BMP图像的JAVA类在 C# 中通过 P/Invoke 调用Win32 DLL - benben - Java... Word，PDF，PPT，TXT之间的转换方法 a Word，PDF，PPT，TXT之间的转换方法a