您的位置:

java中内部类的一些测试,java定义一个测试类

本文目录一览:

java内部类部分的选择题习题及答案 注意是选择题

*类是面向对象编程的基本元素,它定义了一个对象的结构和行为。在Java程序里,要表达的概念封装在类里。一个类定义了一个对象的结构和它的功能接口,功能接口称为成员函数或方法。

类定义中,类名和超类名是合法的标识符。类定义的第一行是类声明,关键字extends表示类是超类派生的子类。在Java中,有一个根类Object,其它的类是直接或间接从它派生而来,如果要定义Object的直接子类,可以省略extends子句,编译器会自动包含它。最外层大括号内为类体,类体中定义了这个类中所有的变量和这个类所支持的方法。通常变量在方法前定义,类中所定义的变量和方法都是类的成员。对类的成员可以设定访问权限,来限定其它对象对它的访问,访问权限可以有private、protected、public和friendly。对类的成员来说,可以分为实例成员和类成员两种。

类名可以作为变量的类型来使用,如果一个变量的类型为一个类,那么它指向的是这个类的实例,叫做对象实例。所有对象实例和它们的类型都是兼容的,就像可以把字节型的值赋予给整型的变量一样,可以把对象的子类的任何实例赋给一个对象型的变量。 *操作符new用来生成一个类的实例,可以用几个变量指向同一个对象。

一个实例是类模板的单独的复制,带有自己的称为实例变量的数据集。一个实例也可以作为一个对象。当定义一个变量的类型是某个类时,它的默认值是null,null是对象型的一个实例。对象null没有值,和整数零不同。

创建一个新的对象时,可以直接对它的实例变量赋值。每个对象都有它所属类的实例变量的副本,每个对象的实例变量都是和其它对象的实例变量分离的,所以改变一个对象的实例变量不会影响其它对象的实例变量。

希望我能帮助你解疑释惑。

Java内部类的特征

1、Inner class 可以声明为抽象类因此可以被其他的内部类继承,也可以声明为final的。

2、和外部类不同,Inner class可以声明为private或protected。

3、Inner class可以声明为static的,但此时就不能再使用外层封装类的非static的成员变量。

4、非static的内部类中的成员不能声明为static的,只有在顶层类或static的内部类中才可以声明 static成员。

Java的内部类有什么特点 作用和注意

1)根据位置的不同,Java中的内部类分为四种:

 静态内部类

 使用static修饰,声明在类体中

 静态内部类中可以访问外部类的静态成员

 成员内部类

 声明在类体中,不使用static,具有类的成员特征,也就是,必须有类的实例才能创建内部类实例

 内部类实例可以访问共享外部类的成员变量(很常用)

 如:链表的节点就可以定义为内部类

 局部内部类 把类声明在方法中,就是局部内部类,作用域

 类似局部变量(很少见)

 匿名内部类

 匿名类,非常常见,可以写在任何地方,就像一般的语句

 语法更象是创建对象:Date d = new Date(){//...};

 匿名类是对原类的一个继承,同时创建了实例,{} 就是继承以后的类体

类体中可使用所有类的语法

 匿名类不能写构造器

 匿名类可以从抽象类或者接口继承,必须提供抽象方法的实现

2) 任何内部类都编译成独立的class文件

3) 最大的作用:封装!

 匿名类可以封装内部概念:情侣间的“土豆”和菜市场的“土豆”是不一样的

java的内部类有什么作用和特点

Java中的内部类共分为四种:

静态内部类static inner class (also called nested class)

成员内部类member inner class

局部内部类local inner class

匿名内部类anonymous inner class

静态内部类Static Inner Class

最简单的内部类形式。

类定义时加上static关键字。

不能和外部类有相同的名字。

被编译成一个完全独立的.class文件,名称为OuterClass$InnerClass.class的形式。

只可以访问外部类的静态成员和静态方法,包括了私有的静态成员和方法。

生成静态内部类对象的方式为:

OuterClass.InnerClass inner = new OuterClass.InnerClass();

示例代码:

package com.learnjava.innerclass;

class StaticInner

{

private static int a = 4;

// 静态内部类

public static class Inner

{

public void test()

{

// 静态内部类可以访问外部类的静态成员

// 并且它只能访问静态的

System.out.println(a);

}

}

}

public class StaticInnerClassTest

{

public static void main(String[] args)

{

StaticInner.Inner inner = new StaticInner.Inner();

inner.test();

}

}

成员内部类Member Inner Class

成员内部类也是定义在另一个类中,但是定义时不用static修饰。

成员内部类和静态内部类可以类比为非静态的成员变量和静态的成员变量。

成员内部类就像一个实例变量。

它可以访问它的外部类的所有成员变量和方法,不管是静态的还是非静态的都可以。

在外部类里面创建成员内部类的实例:

this.new Innerclass();

在外部类之外创建内部类的实例:

(new Outerclass()).new Innerclass();

在内部类里访问外部类的成员:

Outerclass.this.member

示例代码:

package com.learnjava.innerclass;

class MemberInner

{

private int d = 1;

private int a = 2;

// 定义一个成员内部类

public class Inner2

{

private int a = 8;

public void doSomething()

{

// 直接访问外部类对象

System.out.println(d);

System.out.println(a);// 直接访问a,则访问的是内部类里的a

// 如何访问到外部类里的a呢?

System.out.println(MemberInner.this.a);

}

}

}

public class MemberInnerClassTest

{

public static void main(String[] args)

{

// 创建成员内部类的对象

// 需要先创建外部类的实例

MemberInner.Inner2 inner = new MemberInner().new Inner2();

inner.doSomething();

}

}

局部内部类Local Inner Class

局部内部类定义在方法中,比方法的范围还小。是内部类中最少用到的一种类型。

像局部变量一样,不能被public, protected, private和static修饰。

只能访问方法中定义的final类型的局部变量。

局部内部类在方法中定义,所以只能在方法中使用,即只能在方法当中生成局部内部类的实例并且调用其方法。

示例代码:

package com.learnjava.innerclass;

class LocalInner

{

int a = 1;

public void doSomething()

{

int b = 2;

final int c = 3;

// 定义一个局部内部类

class Inner3

{

public void test()

{

System.out.println("Hello World");

System.out.println(a);

// 不可以访问非final的局部变量

// error: Cannot refer to a non-final variable b inside an inner

// class defined in a different method

// System.out.println(b);

// 可以访问final变量

System.out.println(c);

}

}

// 创建局部内部类的实例并调用方法

new Inner3().test();

}

}

public class LocalInnerClassTest

{

public static void main(String[] args)

{

// 创建外部类对象

LocalInner inner = new LocalInner();

// 调用外部类的方法

inner.doSomething();

}

}

匿名内部类Anonymous Inner Class

匿名内部类就是没有名字的局部内部类,不使用关键字class, extends, implements, 没有构造方法。

匿名内部类隐式地继承了一个父类或者实现了一个接口。

匿名内部类使用得比较多,通常是作为一个方法参数。

生成的.class文件中,匿名类会生成OuterClass$1.class文件,数字根据是第几个匿名类而类推。

示例代码:

package com.learnjava.innerclass;

import java.util.Date;

public class AnonymouseInnerClass

{

@SuppressWarnings("deprecation")

public String getDate(Date date)

{

return date.toLocaleString();

}

public static void main(String[] args)

{

AnonymouseInnerClass test = new AnonymouseInnerClass();

// 打印日期:

String str = test.getDate(new Date());

System.out.println(str);

System.out.println("----------------");

// 使用匿名内部类

String str2 = test.getDate(new Date()

{

});// 使用了花括号,但是不填入内容,执行结果和上面的完全一致

// 生成了一个继承了Date类的子类的对象

System.out.println(str2);

System.out.println("----------------");

// 使用匿名内部类,并且重写父类中的方法

String str3 = test.getDate(new Date()

{

// 重写父类中的方法

@Override

@Deprecated

public String toLocaleString()

{

return "Hello: " + super.toLocaleString();

}

});

System.out.println(str3);

}

}

java内部类的方法内部类

把类放在方法内

class Outer {

public void doSomething(){

class Inner{

public void seeOuter(){

}

}

}

}

(1)、方法内部类只能在定义该内部类的方法内实例化,不可以在此方法外对其实例化。

(2)、方法内部类对象不能使用该内部类所在方法的非final局部变量。

因为方法的局部变量位于栈上,只存在于该方法的生命期内。当一个方法结束,其栈结构被删除,局部变量成为历史。但是该方法结束之后,在方法内创建的内部类对象可能仍然存在于堆中!例如,如果对它的引用被传递到其他某些代码,并存储在一个成员变量内。正因为不能保证局部变量的存活期和方法内部类对象的一样长,所以内部类对象不能使用它们。

下面是完整的例子:

class Outer {

public void doSomething(){

final int a =10;

class Inner{

public void seeOuter(){

System.out.println(a);

}

}

Inner in = new Inner();

in.seeOuter();

}

public static void main(String[] args) {

Outer out = new Outer();

out.doSomething();

}

}