精华内容
下载资源
问答
  • java内部类和匿名类

    2021-04-16 15:22:37
    内部类:一个在另一个内部,即我们在一个里面再写一个。 简单来阐述两种内部类的用法: 1.内部类可以直接引用外部的成员变量。 2.在内部类中可以调用外部的对象。 我们何时需要使用内部类: 改内部类...

    内部类:一个类在另一个类的内部,即我们在一个类里面再写一个类。 简单来阐述两种内部类的用法: 1.内部类可以直接引用外部类的成员变量。 2.在内部类中可以调用外部类的对象。 我们何时需要使用内部类: 改内部类不允许或不需要其它类访问时候,这样有助于我们更好的屏蔽底层细节,而且可以使内部类更好地访问外部类的成员变量,这样可以更清楚的组织逻辑,防止不应该被其它类访问的类被访问。

    这只是最简单的内部类,其实我们在实际开发中还会遇到很多情况,例如:内部类的静态与非静态,等等。包括下面的匿名类,也会遇到很多其他情况,例如:匿名类没有名字,所以匿名类也没有构造方法,等等。这些细节就不一一讨论了。

    匿名类:我们直接创建一个接口的一个对象。 例如:

    我们在学习java的过程中,会发java的设计者在java的内部类和匿名类上确实是用心良苦。我们将匿名类和内部类结合起来使用,这也是掌握java高级编程的一部分。我们可以将适配器模式和咱们的匿名内部类综合起来使用,它可以使我们更加优雅的设计我们的程序结构。

    展开全文
  • Java内部类和匿名类

    2021-03-24 10:56:07
    Ø 匿名内部类 内部类的访问特点: 1、内部类可以直接访问外部的成员,包括私有。 2、外部要访问内部类的成员,必须创建对象。 成员内部类 Ø 局部内部类如何使用内部类创建对象? 直接在成员方法内部位置创建该...

    内部类

    概述

    把类定义在其他类的内部,这个类就被称为内部类。

    举例:在类A中定义了一个类B,类B就是内部类。

    内部类位置

    Ø 成员位置(成员内部类)

    Ø 局部位置(局部内部类)

    内部类的种类

    Ø 成员内部类 ----成员变量

    Ø 静态成员内部类 --静态成员变量

    Ø 局部内部类 --局部变量

    Ø 匿名内部类

    内部类的访问特点:

    1、内部类可以直接访问外部类的成员,包括私有。

    2、外部类要访问内部类的成员,必须创建对象。

    成员内部类

    Ø 局部内部类如何使用内部类创建对象?

    直接在成员方法内部位置创建该内部类对象并使用

    Ø 外界如何创建内部类对象?

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

    Ø 成员内部类的修饰符 —成员变量

    基本上成员变量和成员方法能用的修饰符成员内部类都可以用

    例如:四种权限修饰符、static、final、abstracter

    Ø 成员内部类被static修饰后外界如何创建对象

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

    Ø 成员内部类的常见修饰符

    局部内部类

    可以直接访问外部类的成员

    可以创建内部类对象,通过对象调用内部类方法,来使用局部内部类功能

    局部内部类访问局部变量的注意事项:

    必须被final修饰!

    为什么?

    因为局部变量会随着方法的调用完毕而消失,这个时候,局部对象并没有立马从堆内存中消失,还要使用那个变量。为了让数据还能继续被使用,就用fianl修饰,这样,在堆内存里面存储的其实是一个常量值。

    匿名内部类

    匿名内部类就是内部类的简化写法。其本质是一个继承了类或者实现了接口的子类匿名对象。

    使用前提:存在一个类或者接口(这里的类可以是具体类也可以是抽象类)。

    本质:匿名内部类是一个接口或者抽象类的实现类或者子类的对象!

    格式:

    new 类名或者接口名( )
    {
    重写方法;
    }

    匿名内部类在开发中的使用

    首先回顾我们曾经讲过的方法的形式参数是引用类型的情况,重点是接口的情况,我们知道这里需要一个子类对象。而匿名内部类就是一个子类匿名对象,所以,可以使用匿名内部类改进以前的做法。

    展开全文
  • Java内部类(Inner Class),类似的概念在C++里也有,那就是嵌套(Nested Class),乍看上去内部似乎有些多余,它的用处对于初学者来说可能并不是那么显著,但是随着对它的深入了解,你会发现Java的设计者在内部...

    Java内部类(Inner Class),类似的概念在C++里也有,那就是嵌套类(Nested Class),乍看上去内部类似乎有些多余,它的用处对于初学者来说可能并不是那么显著,但是随着对它的深入了解,你会发现Java的设计者在内部类身上的确是用心良苦。学会使用内部类,是掌握Java高级编程的一部分,它可以让你更优雅地设计你的程序结构。下面从以下几个方面来介绍:

    第一次见面

    public interface Contents {

    int value();

    }

    public interface Destination {

    String readLabel();

    }

    public class Goods {

    private class Content implements Contents {

    private int i = 11;

    public int value() {

    return i;

    }

    }

    protected class GDestination implements Destination {

    private String label;

    private GDestination(String whereTo) {

    label = whereTo;

    }

    public String readLabel() {

    return label;

    }

    }

    public Destination dest(String s) {

    return new GDestination(s);

    }

    public Contents cont() {

    return new Content();

    }

    }

    class TestGoods {

    public static void main(String[] args) {

    Goods p = new Goods();

    Contents c = p.cont();

    Destination d = p.dest("Beijing");

    }

    }

    在这个例子里类Content和GDestination被定义在了类Goods内部,并且分别有着protected和private修饰符来控制访问级别。Content代表着Goods的内容,而GDestination代表着Goods的目的地。它们分别实现了两个接口Content和Destination。在后面的main方法里,直接用Contents c和Destination d进行操作,你甚至连这两个内部类的名字都没有看见!这样,内部类的第一个好处就体现出来了——隐藏你不想让别人知道的操作,也即封装性。

    同时,我们也发现了在外部类作用范围之外得到内部类对象的第一个方法,那就是利用其外部类的方法创建并返回。上例中的cont()和dest()方法就是这么做的。那么还有没有别的方法呢?当然有,其语法格式如下:

    outerObject=new outerClass(Constructor Parameters);

    outerClass.innerClass innerObject=outerObject.new InnerClass(Constructor Parameters);

    注意在创建非静态内部类对象时,一定要先创建起相应的外部类对象。至于原因,也就引出了我们下一个话题——

    非静态内部类对象有着指向其外部类对象的引用

    对刚才的例子稍作修改:

    public class Goods {

    private valueRate=2;

    private class Content implements Contents {

    private int i = 11*valueRate;

    public int value() {

    return i;

    }

    }

    protected class GDestination implements Destination {

    private String label;

    private GDestination(String whereTo) {

    label = whereTo;

    }

    public String readLabel() {

    return label;

    }

    }

    public Destination dest(String s) {

    return new GDestination(s);

    }

    public Contents cont() {

    return new Content();

    }

    }

    修改的部分用红色显示了。在这里我们给Goods类增加了一个private成员变量valueRate,意义是货物的价值系数,在内部类Content的方法value()计算价值时把它乘上。我们发现,value()可以访问valueRate,这也是内部类的第二个好处——一个内部类对象可以访问创建它的外部类对象的内容,甚至包括私有变量!这是一个非常有用的特性,为我们在设计时提供了更多的思路和捷径。要想实现这个功能,内部类对象就必须有指向外部类对象的引用。 Java编译器在创建内部类对象时,隐式的把其外部类对象的引用也传了进去并一直保存着。这样就使得内部类对象始终可以访问其外部类对象,同时这也是为什么在外部类作用范围之外向要创建内部类对象必须先创建其外部类对象的原因。

    有人会问,如果内部类里的一个成员变量与外部类的一个成员变量同名,也即外部类的同名成员变量被屏蔽了,怎么办?没事,Java里用如下格式表达外部类的引用:

    outerClass.this

    有了它,我们就不怕这种屏蔽的情况了。

    静态内部类

    和普通的类一样,内部类也可以有静态的。不过和非静态内部类相比,区别就在于静态内部类没有了指向外部的引用。这实际上和C++中的嵌套类很相像了,Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用这一点上,当然从设计的角度以及以它一些细节来讲还有区别。

    除此之外,在任何非静态内部类中,都不能有静态数据,静态方法或者又一个静态内部类(内部类的嵌套可以不止一层)。不过静态内部类中却可以拥有这一切。这也算是两者的第二个区别吧。

    局部内部类

    是的,Java内部类也可以是局部的,它可以定义在一个方法甚至一个代码块之内。

    public class Goods1 {

    public Destination dest(String s) {

    class GDestination implements Destination {

    private String label;

    private GDestination(String whereTo) {

    label = whereTo;

    }

    public String readLabel() { return label; }

    }

    return new GDestination(s);

    }

    public static void main(String[] args) {

    Goods1 g= new Goods1();

    Destination d = g.dest("Beijing");

    }

    }

    上面就是这样一个例子。在方法dest中我们定义了一个内部类,最后由这个方法返回这个内部类的对象。如果我们在用一个内部类的时候仅需要创建它的一个对象并创给外部,就可以这样做。当然,定义在方法中的内部类可以使设计多样化,用途绝不仅仅在这一点。

    下面有一个更怪的例子:

    public class Goods2{

    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) {

    Goods2 g= new Goods2();

    g.track();

    }

    }

    你不能在if之外创建这个内部类的对象,因为这已经超出了它的作用域。不过在编译的时候,内部类TrackingSlip和其他类一样同时被编译,只不过它由它自己的作用域,超出了这个范围就无效,除此之外它和其他内部类并没有区别。

    匿名内部类

    java的匿名内部类的语法规则看上去有些古怪,不过如同匿名数组一样,当你只需要创建一个类的对象而且用不上它的名字时,使用内部类可以使代码看上去简洁清楚。它的语法规则是这样的:

    new interfacename(){......}; 或 new superclassname(){......};

    下面接着前面继续举例子:

    public class Goods3 {

    public Contents cont(){

    return new Contents(){

    private int i = 11;

    public int value() {

    return i;

    }

    };

    }

    }

    这里方法cont()使用匿名内部类直接返回了一个实现了接口Contents的类的对象,看上去的确十分简洁。

    在java的事件处理的匿名适配器中,匿名内部类被大量的使用。例如在想关闭窗口时加上这样一句代码:

    frame.addWindowListener(new WindowAdapter(){

    public void windowClosing(WindowEvent e){

    System.exit(0);

    }

    });

    有一点需要注意的是,匿名内部类由于没有名字,所以它没有构造函数(但是如果这个匿名内部类继承了一个只含有带参数构造函数的父类,创建它的时候必须带上这些参数,并在实现的过程中使用super关键字调用相应的内容)。如果你想要初始化它的成员变量,有下面几种方法:

    如果是在一个方法的匿名内部类,可以利用这个方法传进你想要的参数,不过记住,这些参数必须被声明为final。

    将匿名内部类改造成有名字的局部内部类,这样它就可以拥有构造函数了。

    在这个匿名内部类中使用初始化代码块。

    为什么需要内部类?

    java内部类有什么好处?为什么需要内部类?

    首先举一个简单的例子,如果你想实现一个接口,但是这个接口中的一个方法和你构想的这个类中的一个方法的名称,参数相同,你应该怎么办?这时候,你可以建一个内部类实现这个接口。由于内部类对外部类的所有内容都是可访问的,所以这样做可以完成所有你直接实现这个接口的功能。

    不过你可能要质疑,更改一下方法的不就行了吗?

    的确,以此作为设计内部类的理由,实在没有说服力。

    真正的原因是这样的,java中的内部类和接口加在一起,可以的解决常被C++程序员抱怨java中存在的一个问题——没有多继承。实际上,C++的多继承设计起来很复杂,而java通过内部类加上接口,可以很好的实现多继承的效果。

    java内部类总结

    (1)  在方法间定义的非静态内部类:

    ● 外围类和内部类可互相访问自己的私有成员。

    ● 内部类中不能定义静态成员变量。

    在外部类作用范围之外向要创建内部类对象必须先创建其外部类对象

    (2) 在方法间定义的静态内部类:

    ● 只能访问外部类的静态成员。

    静态内部类没有了指向外部的引用

    (3) 在方法中定义的局部内部类:

    ● 该内部类没有任何的访问控制权限

    ● 外围类看不见方法中的局部内部类的,但是局部内部类可以访问外围类的任何成员。

    ● 方法体中可以访问局部内部类,但是访问语句必须在定义局部内部类之后。

    ● 局部内部类只能访问方法体中的常量,即用final修饰的成员。

    (4) 在方法中定义的匿名内部类:

    ● 没有构造器,取而代之的是将构造器参数传递给超类构造器

    当你只需要创建一个类的对象而且用不上它的名字时,使用匿名内部类可以使代码看上去简洁清楚。

    以上这篇全面了解Java中的内部类和匿名类就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持脚本之家。

    展开全文
  • 匿名内部类一、内部类:(1)内部类的同名方法内部类可以调用外部的方法,如果内部类有同名方法必须使用”OuterClass.this.MethodName()”格式调用(其中OuterClass与MethodName换成实际外部类名及其方法;this为...

    匿名内部类

    一、内部类:

    (1)内部类的同名方法

    内部类可以调用外部类的方法,如果内部类有同名方法必须使用”OuterClass.this.MethodName()”格式调用(其中OuterClass与MethodName换成实际外部类名及其方法;this为关键字,表示对外部类的引用);若内部类无同名方法可以直接调用外部类的方法。

    但外围类无法直接调用内部类的private方法,外部类同样无法直接调用其它类的private方法。注意:内部类直接使用外部类的方法与该方法的权限与是否static无关,它取决于内部类是否有同名方法。

    package innerclass;

    public class OuterClass {

    private void outerMethod() {

    System.out.println(“It’s Method of OuterClass”);

    }

    public static void main(String[] args) {

    OuterClass t = new OuterClass();

    OuterClass.Innerclass in = t.new Innerclass();

    in.innerMethod();

    }

    class Innerclass {

    public void innerMethod() {

    OuterClass.this.outerMethod();// 内部类成员方法与外部类成员方法同名时,使用this调用外部类的方法

    outerMethod();// 内部类没有同名方法时执行外部类的方法

    }

    private void outerMethod() {

    System.out.println(“It’s Method of Innerclass”);

    }

    }

    }

    输出结果为:

    It’s Method of OuterClass

    It’s Method of Innerclass

    (2)内部类访问外部类的变量必须声明为final

    方法中的局部变量,方法结束后这个变量就要释放掉,final保证这个变量始终指向一个对象。

    首先,内部类和外部类其实是处于同一个级别,内部类不会因为定义在方法中就会随着方法的执行完毕而跟随者被销毁。问题就来了,如果外部类的方法中的变量不定义final,那么当外部类方法执行完毕的时候,这个局部变量肯定也就被GC了,然而内部类的某个方法还没有执行完,这个时候他所引用的外部变量已经找不到了。如果定义为final,java会将这个变量复制一份作为成员变量内置于内部类中,这样的话,由于final所修饰的值始终无法改变,所以这个变量所指向的内存区域就不会变。

    注意,若使用jdk1.8,方法中内部类的方法是可以直接访问外部类的方法的局部变量,并且不需要声明为final类型。

    public class OuterClass {

    int num1 = 0;// 成员变量

    private void outerMethod() {

    int num2 = 0;// 方法内的局部变量

    class Innerclass_1 {

    public void innerMethod() {

    System.out.println(num1);// 方法中内部类的方法,可以正常访问外部类的成员变量

    System.out.println(num2);// JDK1.8以前,方法中内部类的方法,不能直接访问外部类的方法的局部变量,必须声明为final

    }

    }

    }

    }

    如果使用JDK1.8以前的版本,Eclipse会出现如下错误提示:

    820f0df8b09af6bde94cd9c445c2ba76.png

    (3)内部类的实例化

    内部类实例化不同于普通类,普通类可以在任意需要的时候实例化,而内部类必须在外层类实例化以后方可实例化,并与外部类建立关系

    因此在外部类中的非static方法中,是可以实例化内部类对象

    private void outerMethod() {

    System.out.println(“It’s Method of OuterClass”);

    Innerclass in = new Innerclass();//在外部类的outerMethod方法中实例化内部类是可以啊

    } 但在static方法中,就要注意啦!!!!不能在static方法中直接new内部类,否则出现错误:

    No enclosing instance of type OuterClass is accessible. Must qualify the allocation with an enclosing instance of type OuterClass (e.g. x.new A() where x is an instance of OuterClass).

    这是因为静态方法是在类实例化之前就可以使用的,通过类名调用,这时动态内部类都还没实例化呢,怎么用,总不能调用一个不存在的东西吧。

    如果想在Static方法中new内部类,可以把内部类声明为Staticpublic class OuterClass {

    private void outerMethod() {

    System.out.println(“It’s Method of OuterClass”);

    }

    public static void main(String[] args) {

    Innerclass in = new Innerclass();

    in.innerMethod();

    }

    static class Innerclass {//把内部类声明为static

    public void innerMethod() {

    System.out.println(“It’s Method of innerMethod”);

    }

    }

    } 当然,一般不使用static的方式,而是推荐这种方法:x.new A() ,其中 x是外部类OuterClass的实例,A是内部类Innerclass

    package innerclass;

    public class OuterClass {

    private void outerMethod() {

    System.out.println(“It’s Method of OuterClass”);

    }

    public static void main(String[] args) {

    OuterClass.Innerclass in = new OuterClass().new Innerclass();//使用x.new A()的方式

    in.innerMethod();

    }

    class Innerclass {

    public void innerMethod() {

    System.out.println(“It’s Method of innerMethod”);

    }

    }

    } x.new A() ,其中 x是外部类OuterClass的实例,A是类部类Innerclass,当然可以拆分如下,这样就显然很明白啦:

    public static void main(String[] args) {

    OuterClass out = new OuterClass();//外部实例

    OuterClass.Innerclass in = out.new Innerclass();//外部实例.new 外部类

    in.innerMethod();

    }

    (4)什么情况下使用内部类

    典型的情况是,内部类继承自某个类或实现某个接口,内部类的代码操作创建其的外层类的对象。所以你可以认为内部类提供了某种进

    入其外层类的窗口。

    使用内部类最吸引人的原因是:每个内部类都能独立地继承自一个(接口的)实现,所以无论外层类是否已经继承了某个(接口的)实

    现,对于内部类都没有影响。如果没有内部类提供的可以继承多个具体的或抽象的类的能力,一些设计与编程问题就很难解决。从这个角

    度看,内部类使得多重继承的解决方案变得完整。接口解决了部分问题,而内部类有效地实现了“多重继承”。

    (5)在静态方法中实例化内部类例子:(内部类放在静态方法中)

    package javatest2;

    public class JavaTest2 {

    public static void main(String[] args) {

    class Boy implements Person {

    public void say() {// 匿名内部类自定义的方法say

    System.out.println(“say方法调用”);

    }

    @Override

    public void speak() {// 实现接口的的方法speak

    System.out.println(“speak方法调用”);

    }

    }

    Person per = new Boy();

    per.speak();// 可调用

    per.say();// 不能调用

    }

    }

    interface Person {

    public void speak();

    }per.speak()可调用,而per.say()不能调用,这时因为per是Person对象,要想调用子类的方法,可以强制向下转型为:((Boy) per).say();或者直接改为Boy per = new Boy();。从中可发现,要想调用内部类的自定义的方法,必须通过内部类的对象来调用。那么,匿名内部类连名字都没有,怎么调用内部类自定义的方法?

    (二)匿名内部类

    匿名内部类也就是没有名字的内部类正因为没有名字,所以匿名内部类只能使用一次,它通常用来简化代码编写,但使用匿名内部类还有个前提条件:必须继承一个父类或实现一个接口,但最多只能继承一个父类,或实现一个接口。

    关于匿名内部类还有如下两条规则:

    1)匿名内部类不能是抽象类,因为系统在创建匿名内部类的时候,会立即创建内部类的对象。因此不允许将匿名内部类定义成抽象类。

    2)匿名内部类不等定义构造器(构造方法),因为匿名内部类没有类名,所以无法定义构造器,但匿名内部类可以定义实例初始化块,

    怎样判断一个匿名类的存在啊?看不见名字,感觉只是父类new出一个对象而已,没有匿名类的名字。

    先看段伪代码

    abstract class Father(){

    ….

    }

    public class Test{

    Father f1 = new Father(){ …. } //这里就是有个匿名内部类

    } 一般来说,new 一个对象时小括号后应该是分号,也就是new出对象该语句就结束了。但是出现匿名内部类就不一样,小括号后跟的是大括号,大括号中是该new 出对象的具体的实现方法。因为我们知道,一个抽象类是不能直接new 的,必须先有实现类了我们才能new出它的实现类。上面的伪代码就是表示new 的是Father的实现类,这个实现类是个匿名内部类。

    其实拆分上面的匿名内部类可为:

    class SonOne extends Father{

    … //这里的代码和上面匿名内部类,大括号中的代码是一样的

    }

    public class Test{

    Father f1 = new SonOne() ;

    }

    先看一个例子,体会一下匿名内部类的用法:

    3ddd7534060071b30ba85e4dc6b53a72.png

    运行结果:eat something

    可以看到,我们直接将抽象类Person中的方法在大括号中实现了,这样便可以省略一个类的书写。并且,匿名内部类还能用于接口上

    public class JavaTest2 {

    public static void main(String[] args) {

    Person per = new Person() {

    public void say() {// 匿名内部类自定义的方法say

    System.out.println(“say方法调用”);

    }

    @Override

    public void speak() {// 实现接口的的方法speak

    System.out.println(“speak方法调用”);

    }

    };

    per.speak();// 可调用

    per.say();// 出错,不能调用

    }

    }

    interface Person {

    public void speak();

    } 这里per.speak()是可以正常调用的,但per.say()不能调用,为什么呢?注意Person per = new Person()创建的是Person的对象,而非匿名内部类的对象。其实匿名内部类连名字都没有,你咋实例对象去调用它的方法呢?但继承父类的方法和实现的方法是可以正常调用的,本例子中,匿名内部类实现了接口Person的speak方法,因此可以借助Person的对象去调用。

    若你确实想调用匿名内部类的自定义的方法say(),当然也有方法:

    (1)类似于speak方法的使用,先在Person接口中声明say()方法,再在匿名内部类中覆写此方法。

    (2)其实匿名内部类中隐含一个匿名对象,通过该方法可以直接调用say()和speak()方法;代码修改如下:

    public class JavaTest2 {

    public static void main(String[] args) {

    new Person() {

    public void say() {// 匿名内部类自定义的方法say

    System.out.println(“say方法调用”);

    }

    @Override

    public void speak() {// 实现接口的的方法speak

    System.out.println(“speak方法调用”);

    }

    }.say();// 直接调用匿名内部类的方法

    }

    }

    interface Person {

    public void speak();

    }

    相关阅读

    Console.WriteLine()表示向控制台写入字符串后换行。Console.WriteLine("鹿鼎记中的{0}的妻子有{1}、{2}、{3}等7个",strName[0],

    最近vi用的多,很多技巧不知道,备注一份,vi编辑器是所有Unix及Linux系统下标准的编辑器,它的强大不逊色于任何最新的文本编辑器,这里只

    在Android系统中,有一种特殊的视图,称为SurfaceView,它拥有独立的绘图表面,即它不与其宿主窗口共享同一个绘图表面。由于拥有独立的绘

    一.概述本文章会详细的介绍RGB颜色空间与RGB三色中色调、饱和度、亮度之间的关系,最后会介绍HSV颜色空间!一.RGB颜色空间1. 起源

    大家应该都玩过天猫密令红包,只是觉得这个活动有意思好玩之外,大家还可以得到一些实惠,毕竟这个红包就是现金。但是对于天猫密令的出

    展开全文
  • 在这个例子里ContentGDestination被定义在了Goods内部,并且分别有着protectedprivate修饰符来控制访问级别。Content代表着Goods的内容,而GDestination代表着Goods的目的地。它们分别实现了两个接口Content...
  • 我们都知道Java中可以使用内部类,将一个的定义放在另一个的定义的内部,这就是内部类,但是匿名内部类往往使我们摸不着头脑,因为它并没有特定的名称,那么该如何使用它呢?定义一个匿名内部类public interface...
  • 包含内部类也被称为外部(有些地方也叫做宿主)我们先创建一个基本的内部类结构:class Outer{//外部//内部类classInner{}}2:内部类的划分内部类分为成员内部类和局部内部类内部类也会生...
  • Java 匿名类(匿名内部类)

    千次阅读 多人点赞 2020-12-25 23:41:48
    Java匿名类(匿名内部类) 学习的参考博文:无恨之都 1. 初识 匿名类 标准说法: 内部类包括:成员、局部匿名类(匿名内部类)。 匿名类概念: 匿名类可以使你的代码更加简洁 (JDK8之后Lambda更简洁)。 你可以...
  • 在一个A的内部再定义一个B,A叫作外部B叫作内部类 内部类 : 成员内部类 vs 局部内部类 成员内部类 : 静态(成员)内部类 vs 非静态(成员)内部类 内部类作为: 可以继承父类,实现接口 类内部...
  • 问:什么JDK8之前内部类中如果有访问外部的成员时,必须要加上final?为什么JDK8不用了?答:我们先不说JDK版本,就说说为什么要加final。我先给出问题的答案:用final修饰实际上就是为了保护数据的一致性。这里所...
  • 本文实例讲述了Java局部内部类和匿名内部类。分享给大家供大家参考,具体如下:一 局部内部类1 点睛内部类不仅可以在中定义,也可以定义在方法体或作用域内。这样的内部类作用范围仅限于方法体或特定的作用域内,...
  • Java类匿名内部类

    2021-03-10 07:39:27
    | 大家好,这篇文章我们主要向大家介绍Java基础中的Object匿名内部类、构造方法的继承知识,一起来学习下吧! |一、ObjectObject是所有的父类,所有都继承Object。Object方法:toString()方法:这个...
  • 一、内部类:(1)内部类的同名方法内部类可以调用外部的方法,如果内部类有同名方法必须使用"OuterClass.this.MethodName()"格式调用(其中OuterClass与MethodName换成实际外部类名及其方法;this为关键字,表示对...
  • 内部类 一个内部又完整的嵌套了另一个结构。被嵌套的称为内部类的五大成员:属性,方法,构造器,代码块,内部类内部类与局部内部类 class Outer { private int n= 100; private void m2() { }...
  • java 匿名内部类

    2021-02-28 07:11:23
    匿名内部类: 匿名内部类与正规的继承相比有些受限,因为匿名内部类既可以扩展,也可以实现接口,但不能两者兼备,而且如果实现接口,也只能实现一个接口一.contents()方法将返回值的生成与表示这个返回值的的定义结合...
  • /*** 匿名内部类的概念特性:* 1、匿名内部类只能也必须(有且仅有)继承一个父类或者实现一个接口,也可以重写父类普通方法;* 2、匿名内部类不能是抽象,因为定义匿名内部类时立即生成对象,而抽象不允许生成...
  • 可以在一个内部定义另一个,这种称为嵌套(nested classes),它有两种类型:静态嵌套类和非静态嵌套。静态嵌套使用很少。第一、下面是静态嵌套(静态内部类):具有以下性质针对非private而言:1,在...
  • 将一个A定义在另一个B里面,里面的那个A就称为内部类,B则称为外部。成员内部类定义在中方法外的。定义格式:class 外部 {class 内部类{}}在描述事物时,若一个事物内部还包含其他事物,就可以使用...
  • 内部类package AA;public class {int de=123;StringBuffer dee=newStringBuffer();public class成员内部类{public voidff() {System.out.println("这是成员内部类方法");}}/*1.可以访问外部所有的成员,包括被...
  • Java 匿名内部类

    2021-03-14 19:13:26
    匿名内部类适合创建只需要一次使用的匿名内部类的格式:new 父类(参数列表) 或 父接口(){//匿名内部类实现部分}匿名内部类必须继承一个父类,或实现一个接口,但最多只能继承一个父类,或实现一个接口。匿名内部...
  • 内部类的介绍定义在另外一个中的,叫内部类成员内部类1..new 创建成员内部类必须先创建外部的实例,然后通过.new 创建内部类的对象2..this 可以通过外部的类名.this去访问外部的所有属性方法。...
  • 正如我发现的那样,使用Stream遍历数组的速度要慢得多(不... 以下示例与Java 8一起运行,没有任何选项://Language is an enumLanguage[] array = Language.values();System.err.println(array.length); // 72 item...
  • 匿名内部类也就是没有名字的内部类正因为没有名字,所以匿名内部类只能使用一次,它通常用来简化代码编写但使用匿名内部类还有个前提条件:必须继承一个父类或实现一个接口实例1:不使用匿名内部类来实现抽象方法...
  • /*** 匿名内部类的概念特性:* 1、匿名内部类只能也必须(有且仅有)继承一个父类或者实现一个接口,也可以重写父类普通方法;* 2、匿名内部类不能是抽象,因为定义匿名内部类时立即生成对象,而抽象不允许生成...
  • // 成员变量定义在中,整个都可以被访问。void run(){System.out.println(color+".."+num);}}classCarDemo{public static void main(String[] args){Car c = new Car();//建立一个c的类型变量,当...
  • 内部类可以使用外嵌类的成员变量和外嵌类的方法,内部类的类名中不可以声明类变量和类方法(用空括号()表示),内部类仅供外嵌类使用,其它类不可以用其它类的内部类去声明对象 public class ZZZ{ String H = ...
  • 内部类的定义:顾名思义,内部类就是在一个的定义中包含另一个的定义!package com.pw.demo; //内部类 public class A { public int i; class B{ public int j; public void show(){ System.out.println(i+j); }...
  • 在本文中是Java内部类匿名内部,主要讲述匿名内部的概念、匿名内部的好处、匿名内部的使用前提、和匿名内部的应用场景。1、匿名内部的概念没有类名的就称作为匿名内部2、匿名内部的好处简化书写...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 155,959
精华内容 62,383
关键字:

java内部类和匿名类

java 订阅