如何使用内部类创建不同的对象
使用内部类创建不同的对象可以通过以下步骤实现：
- 定义外部类：首先，创建一个外部类，可以是普通类或者抽象类。外部类可以包含内部类的定义和其他成员变量和方法。
- 定义内部类：在外部类中定义一个内部类。内部类可以是静态内部类、成员内部类、局部内部类或匿名内部类。每种内部类都有不同的使用场景和特点。
- 创建内部类对象：在外部类的方法中，通过内部类的构造函数创建内部类的对象。可以根据需要创建多个不同的内部类对象。
下面是一个示例代码，演示如何使用内部类创建不同的对象：
public class OuterClass {
private int outerVariable;
// 内部类
public class InnerClass {
private int innerVariable;
public InnerClass(int innerVariable) {
this.innerVariable = innerVariable;
}
public void display() {
System.out.println("Outer variable: " + outerVariable);
System.out.println("Inner variable: " + innerVariable);
}
}
public void createInnerObjects() {
InnerClass innerObject1 = new InnerClass(1);
InnerClass innerObject2 = new InnerClass(2);
innerObject1.display();
innerObject2.display();
}
public static void main(String[] args) {
OuterClass outerObject = new OuterClass();
outerObject.createInnerObjects();
}
}在上面的示例中，OuterClass 是外部类，InnerClass 是内部类。InnerClass 有一个构造函数用于初始化内部类的变量，并且有一个 display() 方法用于显示外部变量和内部变量的值。
在 createInnerObjects() 方法中，我们创建了两个不同的 InnerClass 对象，并调用它们的 display() 方法来显示变量的值。
这种使用内部类创建不同对象的方式可以提供更好的封装性和代码组织性，同时可以访问外部类的成员变量和方法。
相关·内容
我很困惑为什么我应该或者什么时候应该用java编写一个内部类。
假设我在某个ExecutorService类中遇到了像execute这样的方法，execute的.parameter is runnable type.Why，我是否应该为这个方法的参数编写内部类。
还有，继承是如何在内部类上工作的，比如我的类有一些内部类，以及继承(即重载重载)是如何工作的。欢迎使用Pointer\tutorials。预先感谢Gaurav
浏览 3提问于2014-11-18得票数 2
1回答
我读到过非静态内部类比静态内部类会造成更多的内存泄漏。非静态类将生成自身对象实例以及它的外部类作为对它的引用是很好的。
因此，静态内部类可以避免多个对象实例，因为它将创建单个类级对象，而不是实例级。但是它如何避免创建其外部类的实例的对象呢？
Plz有助于理解静态内部类与非静态/匿名内部类内存泄漏。
浏览 3提问于2015-06-17得票数 4
以下是合法的(据我所知)：
class Outer {
void someMethod() {
// do something
}
class Inner {
void innerMethod() {
Outer.this.someMethod();
}
}
}
虽然我理解正在发生什么和结果是什么，但我不明白为什么这是好的。
我很困惑外部类的实例是如何通过静态成员语法访问的：Outer.this不应该this (对外部的一个特定实例的引用)不是静态的吗？语法是相同的，但功能是不同的，还是t
浏览 6提问于2015-07-01得票数 1
回答已采纳
2回答
如何使一个子类只能从实例访问？
、、、、
我想创建一个只能从超类的实例访问的子类，但不能从超类本身访问，以确保超类的变量已经初始化。例如：
public class SuperClass
{
int num;
SuperClass(int number){
num = number;
}
//Make this\/ accessible from instance only
class SubClass
{
SubClass(){}
public int read(){
retur
浏览 6提问于2020-10-04得票数 0
import javax.swing.*;
import javax.swing.event.*;
public class NewGUIStuff{
public static void main(String args[]){
NewGUIStuff gui = new NewGUIStuff();
gui.go();
}
class handlesListListeners implements ListSelectionListener{
public void valueChanged(ListSelect
浏览 2提问于2012-04-18得票数 1
回答已采纳
3回答
我的问题是，如果我有一些类似以下-的代码：
public class OuterClass{
public class InnerClass{
public synchronized methodA(){ /* does something */}
}
}
现在，当多个线程想要调用内部类方法时，它们将获取外部类对象的锁还是内部类对象的锁，以及如何修改语句以便同步对外部类对象的访问。
浏览 0提问于2013-09-20得票数 13
回答已采纳
2回答
这与我对此帖子中提供的一个问题的回答有关：
我记得在我的阅读中，如果你只能从一个匿名内部类创建一个对象，并且出于这个原因，如果你想说创建一个ActionListener类，并且想要从这个类创建多个对象(不使用反射)，那么不要使用匿名内部类，而是使用私有内部类或独立类，但人们告诉我我错了。有人能帮我澄清一下吗？请检查链接，因为它包含更多细节，但如果有任何不清楚，请询问！
浏览 0提问于2011-01-28得票数 13
回答已采纳
静态内部类中非静态字段的实时效用是什么？另外，静态内部类的实例创建是如何工作的：
class Outer {
static class Inner {
public final String text = "Inner";
}
}
public class A {
public static void main(String[] args) {
System.out.println(new Outer.Inner().text);
}
}
浏览 0提问于2016-04-19得票数 0
我正在尝试使用链接来编写哈希表的数据结构。当我从嵌套类中删除关键字"static“时，我收到错误消息"Cannot create a generic array of SeparateChaining.Node"？在我使用new为hmap分配内存的那一行。
使用static关键字，it works fine.Can，任何人请在这里指出关键字static的意义，以及它造成的不同？我正在创建一个对象数组，那么它为什么会在错误中显示泛型数组(Eclipse)？
public class SeparateChaining<Key,Value> {
priv
浏览 2提问于2013-04-25得票数 7
回答已采纳
1回答
内部嵌套类的XML视图异常
、、、、
如果视图类(JavaCameraImageView)作为外部类在XML布局中膨胀，那么我有一些代码工作得很好，没有错误；如果类包含在主活动类外部的同一个.java文件中，那么它也能工作。但是，当我尝试使用JavaCameraImageView类作为主类的内部类时，我会得到这里显示的错误和logcat输出。如何使它作为嵌套的内部类工作？
Logcat结果
01-14 15:17:37.486: E/AndroidRuntime(8347): FATAL EXCEPTION: main
01-14 15:17:37.486: E/AndroidRuntime(8347): java.lang.
浏览 2提问于2014-01-14得票数 1
回答已采纳
2回答
class Outer {
int o = 10;
class Inner {
int i = 20;
}
}
public class Demo {
public static void main(String args[]) {
Outer o = new Outer();
Outer.Inner oi = o.new Inner();
}
}
当我们通过外部类对象创建内部类对象时，它们如何在堆中相互关联？
浏览 2提问于2014-04-04得票数 2
我知道，这个问题已经问过了，我很抱歉又问了一次，但我不知道为什么会这样，有人能帮帮我吗？例如-
public class File
{
public static void main(String[] main)
{
File obj=new File();
obj.method();
}
void method()
{
for(int i=0;i<10;i++)
{
class Inner
{
void
浏览 1提问于2015-08-30得票数 1
当用户旋转android设备时，我正在尝试保存类的状态。我想使用putSerializable和getSerializable函数来获取和设置android Bundle中的类。这个类的简化版本如下所示：
public class State implements Serializable
{
public class Unit implements Serializable
{
private static final long serialVersionUID = 9107072458243854482L;
private String mName;
pri
浏览 5提问于2011-07-05得票数 2
1回答
内部类和子类之间的创建差异
、、、、
我注意到要制作内部类，我们需要外部类的实例。但是，为了创建一个子类，我们还需要父类来创建实例。
如果有的话，他们之间有什么区别？严格地说，是在创造，而不是他们的工作方式。我能想象一下：父级中有对象，内部是子级对象，与堆中内部类对象在外部类中的对象相同吗？我跟这件事有关系吗？
浏览 0提问于2020-10-07得票数 1
回答已采纳
3回答
如果我们有密码的话。
public class Hello
{
public static void main(String args[])
{
Outer obj=new Outer();
obj.method1();
}
}
class Outer
{
void method1()
{
class Inner
{
}
}
}
我想知道，内部类什么时候会被ClassLoader加载。它是在调用method1()的时候加载的，还是在我们将要创建它的实例的时候加载的?
浏览 0提问于2015-06-28得票数 4
正在尝试在父类中创建1个接口和2个具体类。这将把封闭的类限定为内部类。
public class Test2 {
interface A{
public void call();
}
class B implements A{
public void call(){
System.out.println("inside class B");
}
}
class C extends B im
浏览 0提问于2013-06-06得票数 6
回答已采纳
假设我有一个内部类B，我将在外部类的一个成员函数中创建一个实例，有没有一种方法可以在不创建外部类的实例的情况下做到这一点？
非常感谢。
class A {
class B {
}
public void function() {
// create an instance of B, normally have to create a
// instance of A to be bond to by b
B b = new B();
}
}
浏览 1提问于2013-04-12得票数 3
回答已采纳
我有一个扩展Activity并实现ViewFactory的类。
我找到了一些教程和代码示例，它们展示了如何设置和。
对于这两个示例，您必须创建：
public View makeView() {
return x;
}
其中x是textView或ImageView。
下面是我尝试使用的一个示例：
@Override
public View makeView() {
ImageView iView = new ImageView(this);
iView.setScaleType(ImageView.ScaleType.FIT_CENTER);
iView.setL
浏览 0提问于2011-06-30得票数 1
回答已采纳
我的活动中有很多按钮，我有以下问题：
应该为每个按钮为OnClickListeners创建多个内部匿名类，如下所示：
私有View.OnClickListener mShuffleListener =新View.OnClickListener() { public View.OnClickListener onClick(View v) {/ task do }；或是否应该选择一个命名的内部类并添加一个if条件来检查调用哪个单击侦听器。
哪一个更节省内存资源？
浏览 4提问于2012-03-13得票数 7
回答已采纳
我是java编程的初学者，目前正在为libGDX学习编程。在“开始”一书中，有关于如何制作一些基本游戏的说明。其中之一(游戏是处理鼠标和触摸输入的入门游戏)我们制作了一个游戏，在游戏中气球在屏幕的左侧产卵，这些气球不断地向右侧移动，每个气球都被从游戏中移除，无论是单击它，还是当它离开屏幕时(当X大于屏幕的宽度)，我很难理解在这段代码中final的使用：
spawnTimer += delta;
// check time for next balloon spawn
if(spawnTimer > spawnInterval)
{
spawnTimer -= spawnInte
浏览 5提问于2017-09-11得票数 0
回答已采纳
4回答
我正在学习java swing，偶然发现了匿名内部类的概念。在研究了一下这个之后，我觉得匿名内部类必须总是扩展一些其他类，因为它作为参数传递的方法是预定义的。至多，如果一个方法接受对象实例作为参数，那么我们才能创建一个匿名的独立内部类。我只是征求你的意见，看看我是不是对的。如果你能提供一些例子，将会很有帮助。提前谢谢。
浏览 2提问于2012-09-09得票数 3
回答已采纳
为什么编译器会在这里抱怨？它不允许我在main中创建Wrapper对象。MyList是一个单独的类。我如何创建它？
public class BinaryTree {
Node root;
class Wrapper {
MyList.Node node;
}
class Node {
Integer value;
Node left;
Node right;
Node(int value) {
this.value = value;
}
浏览 0提问于2013-05-08得票数 1
回答已采纳
2回答
我正在阅读一些帖子，并注意到带有内部类的示例。我最近经常看到它，特别是在我浏览的MSDN上的几个例子中。我以前从来没有使用过内部类(但也许我真的应该使用)，所以我想知道这到底是什么意思？我假设内部类(至少是私有类)只对主类本身可用，那么简单地将内部类所具有的任何功能合并到外部类的某些方法中不是一样的吗？内部类背后有面向对象的原因吗？
我主要考虑在C#中，但我认为这可以应用于任何支持内部类的OO语言。
以为例: CharacterCollection和WordCollection是Document类中的公共类。如果这些都在Document类之外，会有什么不同？
浏览 0提问于2010-11-03得票数 10
回答已采纳
到目前为止，我还没有实现任何代码，因为我对如何处理这个问题感到困惑。
我被要求实现一个构造器，它应该使用CSV文件中的给定字符串初始化时间和级别字段。那么这个构造函数应该在读入CSV文件的方法中创建Measurement对象吗？
有没有人有办法解决这个问题？
浏览 1提问于2018-02-19得票数 0
1回答
abstract class A {
abstract inner class B : A() {
init {
// How can I access the outer class?
}
}
}
在本例中，this引用类B，this@A引用父类。我如何访问外层类？
测试用例：
abstract class A {
abstract inner class B : A() {
init {
println("Should display 'Parent&#
浏览 3提问于2022-09-19得票数 0
回答已采纳
2回答
public class MyWindow extends JFrame {
JButton botonCreate = new JButton("Open son windows");
public void doSomething(){
botonCreate.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
JDialog vce = new JDialog(t
浏览 5提问于2012-05-12得票数 2
回答已采纳
我编写了一个类，其中有一个内部私有类扩展Thread。我的外部类启动这个线程的一个实例，线程在一个循环中访问外部类的字段。但是，外部代理可以调用外部类上的方法来修改外部类的字段。这些方法必须与线程内的循环同步，这样修改就不会干扰循环。
我在外部类的字段(一个Android SurfaceHolder)上使用一个“同步”块进行同步，将这个对象传递到内部类中，并将对它的引用存储在内部类中，然后在线程的循环中对该内部类字段进行同步。然而，这会导致外部类方法在内部类本应锁定的情况下运行的行为！我试着删除内部字段，并将内部类锁定在与外部类完全相同的字段上，一切都很好。
所以，问题是:通过检查==操作符和
浏览 2提问于2014-01-13得票数 1
回答已采纳
2回答
请考虑以下课程：
package test;
public class Container {
public class Contained {
public void foo() {
System.out.println("printed");
}
}
}
Main.java：
package test;
public class Main {
public static void main(String[] args){
Container c = new Containe
浏览 6提问于2015-01-04得票数 0
回答已采纳
1回答
class B(i:Int) {
var v = new M(i)
class M(i: Int) {
val x = i
println("Creating a new M")
println(s"x = $x")
}
}
val b = new B(1)
val c = new B(2)
b.v = c.v
如何用c.v来改变b内的变量v，为什么不能这样做呢？
浏览 1提问于2016-08-09得票数 1
回答已采纳
我有一个关于性能和编译器如何在Java中工作的问题。
如果我有一个没有任何状态的类，比如
public class Helper {
public String helperMethod(String text) {
....
return value;
}
}
而不是做
public class StaticHelper {
public static String helperMethod(String text) {
....
return value;
}
}
然后我调用了几个类型
new Helper().helperM
浏览 0提问于2017-10-25得票数 0
===结论====
在上找到了一个很好的读卡器
当前的GC算法实际上是为创建许多短期存在的小对象而优化的，因此，我认为在项目中大量使用匿名内部类对于性能而言并不是什么大问题*
========================================================================
由于函数不是当前Java(Java7)中的第一个类公民，使用匿名内部类似乎是实现全异步应用程序的唯一方法。
我知道它会在一定程度上带来更大的内存占用和垃圾收集器负担，但我不知道它会有多严重？最近，我的同事和我争论，因为我的代码是用函数风格编写的，它利用匿名的内部类，他的反对意见
浏览 4提问于2014-01-09得票数 3
回答已采纳
3回答
我很想了解为什么下面的实例化不会编译：
Superclass.Subclass myObject = new Superclass.Subclass();
错误消息如下：
No enclosing instance of type Superclass is accessible. Must qualify the allocation with an enclosing instance of type Superclass (e.g. x.new A() where x is an instance of Superclass).
包围实例是什么意思？为什么有这个必要？
这条消息似乎是在声
浏览 2提问于2017-08-17得票数 0
回答已采纳
如果我在Flash Pro CS5的舞台上创建一个对象，并想在代码中引用它，我该如何做？假设我有两个电影剪辑，我已经将它们转换为元件并指定了实例名称。我如何引用其中的一个剪辑？实例名称似乎不起作用。
浏览 0提问于2010-06-21得票数 0
回答已采纳
1回答
我的项目有个问题：
我有四种类型的文件，一种存储一辆汽车的特性和它停了多久的信息，另一种存储他们从停车收费表上购买的时间的数据，第三种是一个军官级别，取决于他们是否超过了他们购买的时间，或者返回null或者通过使用第四类创建一个停车罚单对象。
不过，我的问题是生成ParkingTicket对象的方法是在军官类中，停车罚单对象必须包含3个参数: car对象、其购买时间后的分钟数和军官对象。但我不知道如何在自己的类中引用军官对象.我知道这个解决方案可能是微不足道的，但我只是有点困惑。
我按照指示创建了军官的副本对象，但我不知道如何在军官类中引用该副本。(我有一个愚蠢的时刻，试图使用副本构造函数的参
浏览 0提问于2014-04-28得票数 3
回答已采纳
在方法中定义的内部类不能访问方法的局部变量，除非这些局部变量被标记为final，我已经看过堆栈溢出和java代码领域中的其他帖子，但它们似乎都没有完全回答标记变量最终如何允许内部类访问方法中的局部变量的问题。
class MyOuter {
private String x = "Outer";
void fly(final int speed) {
final int e = 1;
class FlyingEquation {
public void seeOuter()
{
浏览 7提问于2012-10-23得票数 17
回答已采纳
我发现了一些类似于此的帖子，但找不到一个能敏锐地解释这一点的答案。我已经执行了一个类的嵌套，即类'inside‘存在于类’of‘中，并尝试实例化内部类，这就是我遇到的场景。
就C#而言：
class outside
{
public class inside
{
public void print()
{
System.Console.WriteLine("I am inside");
}
}
}
浏览 5提问于2013-06-07得票数 4
回答已采纳
2回答
我用Java语言编写了这个类(它来自JaCoCo项目)：
public class MemoryMultiReportOutput implements IMultiReportOutput {
private final Map<String, ByteArrayOutputStream> files = new HashMap<String, ByteArrayOutputStream>();
private final Set<String> open = new HashSet<String>();
priv
浏览 0提问于2011-11-18得票数 0
回答已采纳
2回答
我有过
class Class1{
public class Employee{
}
public static void Main(String[] args){
Class1 c = new Class1();
// Create instance of Employee Class
}
}
如何创建类员工的实例？
浏览 5提问于2014-12-14得票数 0
回答已采纳
如果我有以下代码：
class Outer
{
static void Main(string[] args)
{
}
class Inner
{
static void Main(string[] args)
{
}
}
}
默认情况下，哪个main方法将被执行，它会是外部类的main方法吗？
另外，另一个问题是，嵌套的内部类和C#中的内部类有什么不同？
浏览 0提问于2011-03-22得票数 1
回答已采纳
4回答
我知道以前有人问过这个问题，但大多数关于某个库的问题都很具体。而给出的答案并没有真正地向我解释到底发生了什么。
这就是为什么我在这里设置了一个非常简单的测试场景，并试图篡改它，但是仍然有一些问号！！
简单的代码由两个文件组成：
Main.java
public class Main
{
public static void main(String[] args) {
// this works, and inner1 and inner2 seem to be new instances
Outer.Inner inner1 = new Outer.In
浏览 3提问于2020-04-06得票数 2
回答已采纳
3回答
可能重复：
我知道创建非静态内部类对象需要一个外部类对象，而创建的非静态内部类对象自动具有对外部类对象的隐藏引用。但是为什么一个非静态的内部类不能有静态成员呢？Java设计人员只要不允许访问内部类的静态方法中的非静态外部类字段，就更有意义了，不是吗？
如果在内部类中拥有静态成员没有意义，那么为什么内部类可以通过继承具有静态成员的类来继承静态成员呢？
我也读过这个。如上文所述：
内部类可能继承不是编译时常量的静态成员，即使它们可能不声明它们。不属于内部类的嵌套类可以根据Java编程语言的通常规则自由声明静态成员。
这是个会议吗？
这是我的代码：
public class Out
浏览 0提问于2012-07-27得票数 14
回答已采纳
public class MyClass {
int x=9;
public static void main(String args[]) {
MyClass myClass = new MyClass();
myClass.test();
}
public void test(){
int x=10;
class InnerClass{
int x = 11;
void print(){
int x = 12;
浏览 2提问于2018-02-15得票数 3
来自Java文档：
本地类是在块中定义的类，块是平衡大括号之间的一组零或多个语句。您通常会发现在方法的主体中定义的本地类。
此外，Local是一种特殊的内部类，需要从外部类对象实例化
与实例方法和变量一样，内部类与其封闭类的实例相关联。
但是静态块在类加载期间，在创建对象实例之前调用。
那么，如何在静态初始化程序块中创建和实例化本地类呢？
例如：
class OuterClass {
static{
class InitLocalClass {
...
}
InitLocalClass lc = n
浏览 6提问于2016-05-19得票数 0
我有一个超类(Class A)和一些子类(Class B，Class C，Class D)。我想在另一个类(类M)中创建这些子类中的任何一个的对象，这样我就可以将这些对象添加到类M中的数组列表中。
我想知道如何在类M中创建这些子类。
浏览 0提问于2010-12-22得票数 0
回答已采纳
2回答
如果我有一个实体EntityA，它是一个实体框架对象，我该如何在创建时注入不同的行为呢？
这些特定的实体需要在某些计算中使用不同的策略。我想在创建对象时使用DI来提供正确的策略。有没有办法拦截？
补充:我考虑了下面的两种模式(只是伪装来表达观点)。
public partial class Entity
{
public Entity(ICalculationStrategy strategy)
{
_calcStrategy = strategy;
}
}
public
浏览 5提问于2009-07-28得票数 2
2回答
我在那里，
我有这样的场景：
public class A{
//attributes and methods
}
public class B{
//attributes and methods
}
public class C{
private B b;
//other attributes and methods
}
public class D{
private C c1, c2, c3;
private List<A> a;
//other attributes and methods
}
每个类都有自己的文件。但是，我希望将类A、B和
浏览 1提问于2012-05-17得票数 3
回答已采纳
2回答
如果搜索'java双大括号‘，就会发现反对使用它的有力论据。
每当有人使用双支撑初始化时，小猫就会被杀死。
参数是，您创建的匿名类太多了，并且可能会造成内存泄漏。
兰巴斯有什么不同吗？它们各自创建一个匿名的内部类，每个类都引用它们的封闭闭包。
浏览 0提问于2019-04-24得票数 2
回答已采纳
3回答
trait A {
trait B {
def foo: A.this.B = new B{}
def bar: A#B = foo
def baz: A.this.B = bar // type mismatch; found : A#B required: A.this.B
}
}
我说得对吗，A.this.B是一个路径依赖类型？！(到目前为止，这是我的理解)上面的例子是否意味着A.this.B类型是A#B的一个子类型？(如果是的话，我想区别在于A.this.B的实例相对于不引用A的A#B实例有一个引用？)有没有人知道一个有启发性的解释，解决了
浏览 3提问于2011-05-12得票数 4
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
