内部类访问外部类方法

❶ 内部类可以访问外部类的属性和方法吗

外部类名.this.外部类方法

内部类分为：有四种内部类
分别是：静态内部类，成员内部类，局部内部累，匿名内部类。

匿名内部类因为没有类名因此：
1.不能有构造方法

2.不能有任何静态成员方法，或者类

3.不能用修饰符修饰，如public.private,protected

4.必须跟在new一个对象之后

❷ 内部类怎么调用外部同名方法

1.使用static可以声明一个内部类， 可以直接在外部调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Outer{ // 定义外部类
private static String info = "hello world" ; // 定义外部类的私有属性
static class Inner{ // 使用static定义内部类为外部类
public void print(){ // 定义内部类的方法
System.out.println(info) ; // 直接访问外部类的私有属性
}
};
public void fun(){ // 定义外部类的方法
new Inner().print() ; // 通过内部类的实例化对象调用方法
}
};
public class InnerClassDemo03{
public static void main(String args[]){
new Outer.Inner().print() ; // 调用外部类的fun()方法
}
};
2.不使用statc声明一个内部类 ，使外部调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Outer{ // 定义外部类
private String info = "hello world" ; // 定义外部类的私有属性
class Inner{ // 定义内部类
public void print(){ // 定义内部类的方法
System.out.println(info) ; // 直接访问外部类的私有属性
}
};
public void fun(){ // 定义外部类的方法
new Inner().print() ; // 通过内部类的实例化对象调用方法
}
};
public class InnerClassDemo04{
public static void main(String args[]){
Outer out = new Outer() ; // 外部类实例化对象
Outer.Inner in = out.new Inner() ; // 实例化内部类对象
in.print() ; // 调用内部类的方法
}
};
3.在方法中定义内部类 ，使外部调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Outer{ // 定义外部类
private String info = "hello world" ; // 定义外部类的私有属性
public void fun(final int temp){ // 定义外部类的方法
class Inner{ // 在方法中定义的内部类
public void print(){ // 定义内部类的方法
System.out.println("类中的属性：" + info) ; // 直接访问外部类的私有属性
System.out.println("方法中的参数：" + temp) ;
}
};
new Inner().print() ; // 通过内部类的实例化对象调用方法
}
};
public class InnerClassDemo05{
public static void main(String args[]){
new Outer().fun(30) ; // 调用外部类的方法
}
};

❸ 内部类里面的方法怎么访问外部类成员，求解！！！

在内部类使用this表示的是对内部类自身的引用，如果想要获取外部类的引用，应当使用Outer.this，所以访问外部类的方法：
Outer.this.xxxx()

❹ 深入理解java中为什么内部类可以访问外部类的成员

一般来说，外部类调用内部类的方法分为以下几种情况：
1.使用static可以声明一个内部类， 可以直接在外部调用

// 定义外部类
class Outer
{
// 定义外部类的私有属性
private static String info = "hello world";
// 使用static定义内部类
static class Inner
{
// 定义内部类的方法
public void print()
{
// 直接访问外部类的私有属性
System.out.println(info);
}
}
// 定义外部类的方法
public void fun()
{
// 通过内部类的实例化对象调用方法
new Inner().print();
}
}

public class InnerClassDemo03
{
public static void main(String args[])
{
// 通过Outer.Inner创建内部类的实例，并调用它的print方法
new Outer.Inner().print() ;
}
}
2.不使用statc声明一个内部类 ，使外部调用

//定义外部类
class Outer
{
//定义外部类的私有属性
private String info = "hello world";
//定义内部类
class Inner
{
//定义内部类的方法
public void print()
{
//直接访问外部类的私有属性
System.out.println(info);
}
};
//定义外部类的方法
public void fun()
{
//通过内部类的实例化对象调用方法
new Inner().print();
}
};
public class InnerClassDemo04
{
public static void main(String args[])
{
//外部类实例化对象
Outer out = new Outer();
//实例化内部类对象
Outer.Inner in = out.new Inner();
//调用内部类的方法
in.print();
}
}
3.在方法中定义内部类 ，使外部调用

//定义外部类
class Outer
{
//定义外部类的私有属性
private String info = "hello world";
//定义外部类的方法
public void fun(final int temp)
{
//在方法中定义的内部类
class Inner
{
//定义内部类的方法
public void print()
{
//直接访问外部类的私有属性
System.out.println("类中的属性：" + info);
System.out.println("方法中的参数：" + temp);
}
}
//通过内部类的实例化对象调用方法
new Inner().print();
}
}

public class InnerClassDemo05
{
public static void main(String args[]){
//调用外部类的方法
new Outer().fun(30);
}
}

❺ Java内部类怎么直接调用外部类啊

publicclassOuter{
intx;
Strings="hello";
publicvoidtest(){
System.out.print("test");
}
publicclassInner{
ints=20;
publicvoidtestInner(){
//可以直接使用外部类的成员变量和成员方法
x=0;
test();
//如果外部类的成员变量和内部类变量重名，可以这样调用外部类的变量
Outer.this.s="test";
//当然你可以new外部类对象这也是没问题的
Outero=newOuter();
o.x=30;
o.test();
}
}
}

❻ java内部类可以访问外部类的静态方法吗

内部类
就相当于一个外部类的成员变量，所以可以直接访问
外部变量
，外部类不能直接访问内部类变量，必须通过创建内部类实例的方法访问，
new
InnerClass
(32).m就是创建内部类实例访问内部类成员变量。
你想不通的肯定是指内部类的私有变量怎么可以被外部类访问吧，按常规，私有变量m只能在InnerClass里被访问，
但你要注意，内部类就相当于一个外部类的成员变量，举个例子。
class
Outer{
private
int
m;
private
class
Inner{
private
int
n;
private
int
k;
}
}
m和类Inner都是成员变量，他们之间是平等的，唯一不同的就是Inner它是包装了几个成员变量比如n,k，也就是说m
n
k是平等的，区别在于访问n
k要通过Inner，就是要建立Inner实例访问nk，这样解释够明白了吧

❼ c++内部类访问外部类的方法

内部类就是外部类的友元类，内部类可以通过外部类的对象来访问外部类的所有成员。

❽ java 内部类怎么调用外部类的函数

你好！
方法1：定义内部类的一个对象，用该对象调用外部类的成员函数
方法2：直接用语句：this.外部类的成员函数名。
仅代表个人观点，不喜勿喷，谢谢。

❾ java内部类可以访问外部类的静态方法吗

内部类
就相当于一个外部类的
成员变量
，所以可以
直接访问
外部变量
，外部类不能直接访问内部类变量，必须通过创建内部类实例的方法访问，
new
InnerClass
(32).m就是创建内部类实例访问内部类成员变量。
你
想不通
的肯定是指内部类的私有变量
怎么可以
被外部类访问吧，按常规，私有变量m只能在InnerClass里被访问，
但你要注意，内部类就相当于一个外部类的成员变量，举个例子。
class
Outer{
private
int
m;
private
class
Inner{
private
int
n;
private
int
k;
}
}
m和类Inner都是成员变量，他们之间是平等的，唯一不同的就是Inner它是包装了几个成员变量比如n,k，也就是说m
n
k是平等的，区别在于访问n
k要通过Inner，就是要建立Inner实例访问nk，这样解释够
明白了吧