澳门新萄京Java面向对象的三大特色,JavaSE入门学
分类:www.澳门新萄京赌场

Java中的内部类

java面向对象的三大特点,封装,承袭,多态

JavaSE入门深造1四:Java面向对象之内部类

  • 封装

壹. 哪些是JAVA中的封装

 

 

一内项目概述

里头类(Inner Class)正是概念在其余2个类里面包车型地铁类。与之对应,包罗个中类的类被叫作外部类。

其中类的显要功能如下:

A内部类提供了越来越好的包装,能够把内部类隐藏在外部类之内,差别意同二个包中的别的类访问该类。

B内项指标方式可以间接待上访问外部类的享有数据,包罗个人的多少。

C内部类所完毕的效劳使用外部类同样能够兑现,只是偶然利用此中类更有益。

里面类可分为以下三种:

A成员内部类

B静态内部类

C方法内部类

D无名氏内部类

  1. 将类的一点新闻隐藏在类的里边,不容许外部程序直接访问,而是经过此类提供的艺术类完结对逃匿音讯的操作和访问。
  2. 包裹的达成步骤:修改属性的可知性(设为private)=>创制setter和getter方法(用于属性的读写)=>在setter和getter方法中投入属性决定语句(对属性值的合法性举办推断)

面向对象的三大特点:封装、继承、多态、

  1. 封装
  • 概念:将类的一些音信隐藏在类内部,不允许外部程序间接待上访问,而是通过此类提供的点子来落到实处对藏身音讯的操作和做客。
  • 好处:
    只可以通过规定的措施访问数据
    隐藏类的实例细节,方便修改和促成
  • 查封的兑现步骤
    修改属性的可见性(高为private) -> 创建getter/setter方法(用于属性的读写) -> 在getter/setter方法中出席属性决定语句(对属性值的合法性举办判定)

 

装进,毫无疑问,就是外表程序不能直接待上访问内部成员

1/申胥内部类

其中类中最常见的正是成员内部类,也叫做普通内部类。大家来看如下代码:

澳门新萄京 1

运维结果为:

澳门新萄京 2

从地点的代码中大家能够见见,成员内部类的接纳格局:

壹)Inner类定义在Outer类的里边,相当于Outer类的一个成员变量的任务,Inner类能够采纳自便拜访调整符,如

public、protected、private等。

2)Inner类中定义的test()方法能够一直访问Outer类中的数据,而不受访问调控符的震慑,如直接待上访问Outer类中的

个人属性a。

三)定义了成员内部类后,必须选拔外部类对象来创制内部类对象,而不能够直接去new三个内部类对象,即:内部

类 对象名 = 外部类对象.new内部类( )。

四)编写翻译上面包车型地铁先后后,会意识产生了八个.class文件:

澳门新萄京 3

个中,首个是外项指标 .class 文件,第二个是内项指标.class 文件,即成员内部类的 .class 文件再三再四这么:外

品类名$内部类名.class。

应用外部类的注意事项有:

A外部类是不能够直接使用当中类的分子和办法的,可先创制内部类的靶子,然后通过中间类的靶子来走访其成员

变量和形式。

澳门新萄京 4

B假使外部类和当中类具备同等的成员变量或措施,内部类暗许访问本人的分子变量或艺术,假如要访问外部类

的分子变量,能够应用 this 关键字。如:

澳门新萄京 5

运行结果:

澳门新萄京 6

  • Java中的包

贰.用到包管理java中的类

一:什么是内部类;

  (壹).什么是里面类呢?

  内部类( Inner Class )就是概念在别的1个类里面包车型客车类。与之相应,包含当中类的类被叫做外部类。

  (二).那为啥要将三个类定义在另1个类里面呢?独立的三个类倒霉吗?

 

  内部类的严重性功用如下:

 

一. 里边类提供了越来越好的卷入,能够把内部类隐藏在外部类之内,不允许同1个包中的此外类访问该类

 

二. 里边类的主意能够向来访问外部类的有所数据,包罗个人的多寡

 

3. 之中类所达成的效益使用外部类一样能够兑现,只是有的时候利用个中类更有利

  (3)内部类有两种呢?

  内部类可分为以下二种:

  • 成员内部类
  • 静态内部类
  • 澳门新萄京Java面向对象的三大特色,JavaSE入门学习1四。格局内部类
  • 佚名内部类

隐藏属性,通过艺术来做客或拍卖对象,而不是间接操作原始数据

3静态内部类

静态内部类是static修饰符去修饰的中间类,这种中间类的个性是:

A静态内部类不能够一向访问外部类的非静态成员,但能够透过 new 外部类().成员 的点子访问。

B如若外部类的静态成员与中间类的分子名称一致,可因而“类名.静态成员”访问外部类的静态成员;若是外部类

的静态成员与当中类的成员名称不雷同,则可经过“成员名”直接调用外部类的静态成员。

C创造静态内部类的靶龙时,没有供给外表类的对象,能够间接创立 内部类 对象名= new 内部类():

澳门新萄京 7

运营结果:

澳门新萄京 8

  1. 包的效应:管理Java文件;化解同名文件争持
  2. 概念包:package 包名,注意:必须放在Java源程序的率先行;包名间能够应用“.”号隔开分离,如:com.test.Myclass
  3. 系统中的包:java.(效用).(类)
  4. 包的选取:能够由此import关键字,在某些文件使用其余文件中的类。如import com.test.Myclass;
  5. java中,包的命名规范是全小写字母拼写。
  6. 动用包的时候,不但能够加载有些包下的持有文件,如:com.test.*;也得以加载某些具体子包下的装有文件,如:com.test.music.*

3. java中的访问修饰符

做客修饰符:能够修饰属性和措施的造访范围

访问修饰符 本类 同包 子类
private
默认
protected
public

贰:Java 中的成员内部类;

  内部类中最分布的就是成员内部类,也称为普通内部类。咱们来看如下代码:

 

//外部类HelloWorld
public class HelloWorld{

    private int a = 99;//外部类的私有属性
    //内部类Inner
    public class Inner{
        int b = 2;
        public void test(){
        System.out.println("访问外部类中的a:" a);
        System.out.println("访问内部类中的b:" b);
        }
    }
    //测试成员内部类
    public static void main(String[]args){
        HelloWorld o = new HelloWorld();//创建外部类对象,对象名为o
        Inner i = o.new Inner();//使用外部类对象创建内部类对象,对象名为i
        i.test();//调用内部类对象的test方法
    }
}

 

运维结果为:

澳门新萄京 9

 

从上边的代码中大家得以看来,成员内部类的施用办法:

 

一、 Inner 类定义在 HelloWorld类的内部,也正是 HelloWorld 类的八个成员变量的职位,Inner 类能够应用自便拜访调节符,如 public 、 protected 、 private 等

 

二、 Inner 类中定义的 test() 方法能够直接待上访问 HelloWorld类中的数据,而不接受访问问调节符的影响,如直接待上访问 HelloWorld类中的私有属性a

 

三、 定义了成员内部类后,必须运用外部类对象来创建内部类对象,而无法直接去 new 1个内部类对象,即:内部类 对象名 = 外部类对象.new 内部类( );

 

四、 编写翻译下面的顺序后,会发觉产生了两个.class 文件

 

HelloWorld.class

HelloWorld$Inner.class

 

  当中,第3个是外项目的.class 文件,第12个是内项目标 .class 文件,即成员内部类的 .class 文件一而再这么:外部类名$内部类名.class

 

澳门新萄京Java面向对象的三大特色,JavaSE入门学习1四。另外,注意:

壹、 外部类是无法一向利用当中类的积极分子和章程滴

澳门新萄京 10

  可先创立内部类的靶子,然后经过中间类的对象来做客其成员变量和办法。

2、 假如外部类和里面类具有同等的积极分子变量或格局,内部类暗中认可访问本人的成员变量或方法,如若要拜访外部类的分子变量,能够利用 this 关键字。如:

//外部类HelloWorld
public class HelloWorld{

    int b = 1;
    //内部类Inner
    public class Inner{
        int b = 2;
        public void test(){
        System.out.println("访问外部类中的b:" HelloWorld.this.b);
        System.out.println("访问内部类中的b:" b);
        }
    }
    //测试成员内部类
    public static void main(String[]args){
        HelloWorld o = new HelloWorld();//创建外部类对象,对象名为o
        Inner i = o.new Inner();//使用外部类对象创建内部类对象,对象名为i
        i.test();//调用内部类对象的test方法
    }

}

运营结果为:

澳门新萄京 11

 

 

4方法内部类

措施内部类正是中间类定义在外部类的艺术中,方法内部类只在该措施的内部可知,即只在该形式中得以运用。

澳门新萄京 12

内需小心的事项有:

鉴于措施内部类不能够在外部类的诀窍以外的地方使用,由此方法内部类无法动用访问调节符和 static修饰符静态

无法访问非静态,非静态既能够访问静态也足以访问非静态。

一内项目概述 内部类(Inner Class)正是概念在别的贰个类里面包车型客车类。与之相应,蕴涵个中类的类被称为...

  注:默许景况下,java会将同两个包内的类活动导入

JAVA中的this关键字

  1. this 关键字表示当前目的
    this.属性 操作当前目的的习性
    this.方法,调用当前目的的点子
  2. 包裹对象属性的时候,常常会用

  3. 如何是Java的内部类

  4. 概念:定义在其余类里面包车型大巴类,与之相应,包蕴当中类的类称为外部类

  5. 作用:
  • 提供了更加好的包装,能够把内部类隐藏在外部类之内,不允许同多少个包中的别样类访问。
  • 内部类的艺术能够访问外部类的持有数据,包含私有多少
  • 其间类所完毕的成效利用外部类一样能够兑现,只是不经常候利用个中类更有利
  • 种类:
    • 分子内部类
    • 静态内部类
    • 艺术内部类
    • 无名内部类

叁:Java 中的静态内部类;

  静态内部类是 static 修饰的内部类,这种中间类的脾气是:

1、 静态内部类不能够一向访问外部类的非静态成员,但能够通过 new 外部类().成员 的不二等秘书技访问 

二、 如若外部类的静态成员与中间类的分子名称一样,可由此“类名.静态成员”访问外部类的静态成员;假若外部类的静态成员与个中类的分子名称差别等,则可经过“成员名”直接调用外部类的静态成员

三、 成立静态内部类的对象时,没有需求外部类的目标,能够一贯开立 内部类 对象名= new 内部类();

比如:

//外部类HelloWorld
public class HelloWorld{

    private int a = 99;//外部类的私有变量
    static int b = 1;//外部类的静态变量
    //静态内部类
    public static class SInner{
        int b =2;
        public void test(){
        System.out.println("访问外部类中的b:" HelloWorld.b);
        System.out.println("访问内部类中的b:" b);
        }
    }
    //测试静态内部类
    public static void main(String[]args){
        SInner si = new SInner();//直接创建内部类的对象
        si.test();//调用test方法
    }
}

运营结果为:

澳门新萄京 13

 

卷入的贯彻步骤

  以下定义了七个同名Telephone的类:

5.成员内部类

//外部类
public class outer{
private int a = 9玖;//外部类的私家属性
//内部类
private class Inner{
int b = 二;//内部类的积极分子属性
public void test(){
System.out.println("访问外部类中的a:" a);
System.out.println("访问内部类中的b:" b);
}
}
//调用成员内部类
public static void main(String[] args){
outer o = new Outer();//创制外部对象o
Inner i = new Inner();//使用外部类对象创制内部类对象,名为i
i.test();//调用内部类对象的test方法
}
}

分子内部类的保用方法:

  • 1.Inner类定义在Outer类的中间,相当于Outer类的一个分子变量的岗位,Inner类可以利用大4拜访调节符,public,protercted,private
  • 贰.Inner类中宣言的test()方法能够直接待上访问Outer类中的数据 ,面不受访问调节符的影响,如直接待上访问Outer类中的私有属性a
  • 三.定义了成员 内部类后,必须利用外部类对象来创建内部类对象,而不可能直接newg 二个内部类对象,即:内部类.对象名 = 外问类对象.new 内部类();
  • 肆.编写翻译上边的程序后,会发觉发生了五个.class文件outer$Inner.classOuter.class。个中第一个是外项目标.class文件,第二个里面类的.class文件,即成员 内部类的.class文件接二连三如此:外部类名$内部类名.class

友情提醒:

  • 外部类是不能够直接运用其中类的成员 和措施,可先创制内部类的目的,然后通过中间类的靶子来拜访其成员变量和方式。
  • 假如 外部类和中间类具备同样的分子 变量和艺术,内部类暗许访问本身的积极分子 变量或情势,假如访问外问类的成员变量,能够用this.

肆:Java 中的方法内部类;

  方法内部类正是里面类定义在外部类的艺术中,方法内部类只在该形式的当中可知,即只在该方法内足以应用。

举多少个例证:

 

//外部类HelloWorld
public class HelloWorld{

    //外部类中的方法
    public void show(){
        final int a =25;//常量
        int b = 13;//变量
        //方法内部类
        class MInner{
            int c =2;//内部类中的变量
            public void print(){
                System.out.println("访问外部类的方法中的常量a:" a);
                System.out.println("访问内部类中的变量c:" c);
            }
        }
        MInner mi = new MInner();//创建方法内部类中的对象
        mi.print();//调用内部类中的方法
    }
    //测试方法内部类
    public static void main(String[]args){
        HelloWorld mo = new HelloWorld();
        mo.show();//调用外部类的方法
    }
}

 

瞩目:由于方法内部类无法在外部类的主意以外的地点选用,因而方法内部类无法应用访问调控符和 static 修饰符。

 

 

package com.test;

public class Telephone {
    private double screen;
    public double getScreen() {
        return screen;
    }
    public void setScreen(double newScreen) {
        screen = newScreen;
    }
    public Telephone(){
        System.out.println("com.test.Telephone无参数的构造方法");
    }
}

陆.静态内部类

用static修饰,特点是:

  1. 静态内部类无法平素访问外部类的非静态成员,但足以透过new外部类().成员的法子访问
  2. 一经外部类的静态成员与个中类的成员名称一致,可通过“类名.静态成员”访问外部类的静态成员,假如外部类的静态成员 与个中类的成员名称不平等,则可透过“成员名”直接调用外部类的静态成员
    三.创制静态内部类的靶卯时,无需外表类的对象,能够直接开立内部类 对象名 = new 内部类();

//外部类
public class SOuter{
private int a = 9玖;//外部类民用变量
static int b = 壹;//外部类的静态变量
//静态内部类
public static class SInner{
int b = 贰;//内部类的变量
public void test(){
System.out.println("访问外部类中的b:" SOuter.b);
System.out.println("访问内问类中的a:" b);
澳门新萄京,}
}
//测试静态的里边类
public static void main(String[] args){
SInner si = new SInner();//直接创制内部类的对象
si.test();//调用test
}
}

一,修改属性的可知性,设为private

 

柒.Java 中的方法内部类

艺术内部类正是个中类定义在外部类的方法中,方法内部类只在该办法的里边可知,即只在该措施内能够选拔

//外部类
public class MOuter{
//外部类中的方法
public void show(){
final int a = 25;常量
int b = 13;变量
//方法内部类
class MInner{
int c = 2;
public void print(){
System.out.println("访问外部类格局中的常量a:" a);
System.out.println("访问内部类中变量c:" c);
}
}
MInner mi = new MInner(String[] args){//创设方法内部类的指标
mi.print();//调用内部类的秘诀
}
//测试方法内部类
public static void main(String[] args){
MOuter mo = new MOuter();//创制外部类的指标
mo.show();//调用外部类的法子
}
}
}

出于内部类不能够在外部类的主意以外的地点使用,因而方法内部类不能够应用访问调控符和static修饰符

二,创制getter/setter方法,用于属性的读写

package com.test.second;

public class Telephone {
    public Telephone() {
        System.out.println("com.test.secont.Telephone");
    }
}

3,在getter/setter方法中进入属性决定语句

  Demo.java

 

package com.test;
import com.test.Telephone;

public class Demo {

    public static void main(String[] args) {
        Telephone phone = new Telephone();
    }

}

运用包来管理java中的类

  运营结果:

包和文件夹的效率是看似的

  com.test.Telephone无参数的构造方法

定义包:package 包名

package com.test;
import com.test.second.Telephone;

public class Demo {

    public static void main(String[] args) {
        Telephone phone = new Telephone();
    }

}

小心必须放在java源程序的首先行

  运转结果:

包名间能够使用.隔绝,分档次的

  com.test.secont.Telephone

 

  • 访问修饰符

系统中的包

  1. 能够修饰属性和措施的访问范围

java.lang.(class) 包罗java语言基础的类

访问修饰符 本类 同包 子类 其他
private      
默认    
protected  
public

java.util.(class)包括java语言中种种工具类

  •  this关键字

java.io.(class)包好输入,输出相关职能的类

  this代表当前目的,this.属性 操作当前目的的习性;this.方法 调用当前目的的不二等秘书技

包的选择

  • 内部类

通过import关键字

  内部类,是概念在另一个类里面包车型客车类,与之相应,包括当中类的类被称之为外部类。

java中,包名都是以全小写字母命名的。

  内部类的职能:

 

  1. 里头类提供了更加好的卷入,能够把内部类隐藏在外部类之内,不允许同1个包中的其余类访问该类
  2. 个中类的章程能够直接访问外部类的富有数据,蕴含个人的数码
  3. 内部类所完结的作用应用外部类同样能够兑现,只是偶然利用当中类更有益
  4. 其间类分为:成员内部类、静态内部类、方法内部类、无名氏内部类

java中的访问修饰符

  •  成员内部类

 澳门新萄京 14 

  澳门新萄京 15

 

  1. Inner 类定义在 Outer 类的在那之中,相当于 Outer 类的多少个分子变量的地点,Inner 类能够行使大四拜访调控符,如 public 、 protected 、 private 等
  2. Inner 类中定义的 test() 方法能够直接待上访问 Outer 类中的数据,而不受访问调控符的影响
  3. 概念了成员内部类后,必须采纳外部类对象来创制内部类对象,而不能够一向去 new 2个里面类对象,即:内部类 对象名 = 外部类对象.new 内部类( );
  4.  编写翻译上面的顺序后,会发觉发生了多少个 .class 文件,Outer$Inner.class和Outer.class,第四个是外项目标 .class 文件,第二个是内项目标 .class 文件,即成员内部类的 .class 文件一而再这么:外部类名$内部类名.class

java中的this关键字

  注意:

 

  1. 外表类是不能间接行使个中类的积极分子和方式
  2. 万一外部类和内部类具有同样的成员变量或方法,内部类默许访问自身的积极分子变量或措施,借使要拜访外部类的成员变量,能够动用 this 关键字

一,this关键字表示当前目的

  澳门新萄京 16

eclipse中自动生成get/set方法

  • 静态内部类

source->Generate Getters and Setters

  澳门新萄京 17

 

  1. 静态成员类不能够直接待上访问外部类的非静态成员,能够经过new 外部类().成员来拜会
  2.  假若外部类的静态成员与中间类的分子名称同样,可因此“类名.静态成员”访问外部类的静态成员;假如外部类的静态成员与当中类的分子名称不雷同,则可经过“成员名”直接调用外部类的静态成员
  3. 创制静态内部类的对象时,无需外部类的目的,能够向来开立 内部类 对象名= new 内部类();

怎样是 Java 中的内部类

  • 方法内部类

 

  方法内部类是内部类定义在外部类的办法中。方法内部类只在该方法的中间可知。

问:什么是内部类呢?

  注意:由于方法内部类无法在外部类的不2法门以外的地点选拔,由此方法内部类无法利用访问调控符和static修饰符。

答:内部类( Inner Class )就是概念在别的2个类里面包车型大巴类。与之对应,包罗当中类的类被叫做外部类。

package com.test;

public class Demo12 {

    public void show() {
        final int a = 12;
        int b = 13;

        class MInner {
            int c= 2;
            public void print() {
                System.out.println("外部类方法中的变量a="   a);
                System.out.println("外部类方法中的变量b="   b);
                System.out.println("内部类中的变量c="   c);
            }
        }
        MInner mi = new MInner();
        mi.print();
    }

    public static void main(String[] args) {
        Demo12 demo = new Demo12();
        demo.show();
    }
}

问:那干什么要将1个类定义在另3个类里面呢?清清爽爽的独门的3个类多好哎!!

  运维结果:  

答:内部类的要害作用如下:

  外部类措施中的变量a=12
  外部类措施中的变量b=一3
  内部类中的变量c=2

一. 里面类提供了越来越好的包装,能够把内部类隐藏在外部类之内,不允许同贰个包中的别样类访问该类

  1. 里面类的措施能够直接访问外部类的持有数据,包罗个人的数据

  2. 中间类所完毕的效应采纳外部类同样能够兑现,只是有的时候利用其中类更方便

问:内部类有两种啊?

答:内部类可分为以下两种:

分子内部类

静态内部类

艺术内部类

无名内部类

 1 //外部类HelloWorld
 2 public class HelloWorld {
 3     // 内部类Inner,类Inner在类HelloWorld的内部
 4     public class Inner {
 5        // 内部类的方法
 6       public void show() {
 7          System.out.println("welcome to Java!");
 8      }
 9    }
10    public static void main(String[] args) {
11        // 创建外部类对象
12       HelloWorld hello = new HelloWorld();
13       // 创建内部类对象
14       Inner i = hello.new Inner();
15       // 调用内部类对象的方法
16       i.show();
17   }
18 }

不错领悟这些程序,为何能够唯有在main方法里能够new一个当下类的目标,因为它被static修饰。

 

 1 //外部类HelloWorld
 2 public class HelloWorld {
 3     private int a = 100;
 4     // 内部类Inner,类Inner在类HelloWorld的内部
 5     public class Inner {
 6         int b = 50;
 7         // 内部类的方法
 8         public void test() {
 9             System.out.println("访问外部类中的a:"   a);
10             System.out.println("访问内部类中的b:"   b);
11         }
12     }
13     public static void main(String[] args) {
14        // 创建外部类对象
15       HelloWorld hello = new HelloWorld();
16       // 创建内部类对象
17       Inner i = hello.new Inner();
18       // 调用内部类对象的方法
19       i.test();
20     }
21 }

从地点的代码中大家得以看出,成员内部类的使用方式:
1、 Inner 类定义在 HelloWorld类的当中,也就是 HelloWord 类的四个分子变量的地方,Inner 类能够行使放肆拜访调整符,如 public 、 protected 、 private 等
2、 Inner 类中定义的 test() 方法能够一贯访问 HelloWorld 类中的数据,而不受访问调控符的震慑,如直接待上访问 HelloWord 类中的私有属性a
三、 定义了成员内部类后,必须接纳外部类对象来创建内部类对象,而不可能一贯去 new 二个里面类对象,即:内部类 对象名 = 外部类对象.new 内部类( );
四、 编译下面的程序后,会意识产生了七个 .class 文件
别的,友情提醒哦:
一、 外部类是不可能一向接纳个中类的积极分子和章程滴
二、 倘使外部类和里面类具有一样的分子变量或格局,内部类暗中同意访问自个儿的积极分子变量或方法,假若要访问外部类的成员变量,能够行使 this 关键字

 1 //外部类HelloWorld
 2 public class HelloWorld {
 3     private int a = 100;
 4     // 内部类Inner,类Inner在类HelloWorld的内部
 5     public class Inner {
 6         int a = 50;
 7         // 内部类的方法
 8         public void test() {
 9             // 访问外部类中的成员属性b
10             System.out.println("访问外部类中的a:"   HelloWorld.this.a);
11             System.out.println("访问内部类中的a:"   a);
12         }
13     }
14     public static void main(String[] args) {
15        // 创建外部类对象
16       HelloWorld hello = new HelloWorld();
17       // 创建内部类对象
18       Inner i = hello.new Inner();
19       // 调用内部类对象的方法
20       i.test();
21     }
22 }

Java 中的静态内部类

静态内部类是 static 修饰的内部类,这种中间类的特色是:

一、 静态内部类不能够从来访问外部类的非静态成员,但足以因此 new 外部类().成员 的主意访问

二、 假使外部类的静态成员与中间类的分子名称一样,可透过“类名.静态成员”访问外部类的静态成员;要是外部类的静态成员与中间类的分子名称不相同,则可经过“成员名”直接调用外部类的静态成员

三、 创建静态内部类的指标时,不须求外表类的指标,可以一向开立 内部类 对象名= new 内部类();

//外部类HelloWorld
public class HelloWorld {
    private int a = 99;
    static int b = 1;
    // 静态内部类
    public static class SInner {
        // 内部类的变量
        int b = 2;
        // 内部类的方法
        public void test() {
            System.out.println("访问外部类中的b:"   HelloWorld.b);
            System.out.println("访问内部类中的b:"   b);
        }
    }
    public static void main(String[] args) {
      // 直接创建内部类的对象
      SInner si = new SInner();
      si.test();
    }
}

Java 中的方法内部类

格局内部类便是中间类定义在外部类的主意中,方法内部类只在该措施的内部可见,即只在该形式内得以使用

 1 //外部类HelloWorld
 2 public class HelloWorld {
 3     public void show() {
 4         // 常量
 5         final int a = 25;
 6         int b = 13;
 7         // 方法内部类
 8         class Inner {
 9             // 内部类中的变量
10             int c = 2;
11             public void print() {
12                 System.out.println("访问外部类的方法中的常量a: "   a);
13                 System.out.println("访问内部类中的变量c: "   c);
14             }
15         }
16         // 创建方法内部类的对象
17         Inner i = new Inner();
18         i.print();
19     }
20     public static void main(String[] args) {
21       // 创建外部类的对象
22       HelloWorld hello = new HelloWorld();
23       // 调用外部类的方法
24       hello.show();
25     }
26 }

毫无疑问要专注哦:由于措施内部类不可能在外部类的情势以外的地点接纳,因而方法内部类不能利用访问调整符和 static 修饰符

本文由澳门新萄京发布于www.澳门新萄京赌场,转载请注明出处:澳门新萄京Java面向对象的三大特色,JavaSE入门学

上一篇:PowerDesigner使用教程,PowerDesigner用法和才能 下一篇:没有了
猜你喜欢
热门排行
精彩图文