java-07 内部类、匿名内部类、局部内部类、lambda

本文主要记录内部类、匿名内部类、局部内部类、lambda表达式的用途和lambda表达式的推导及使用

1.直接内部类

  直接内部类可以分为两种: 成员内部类和静态内部类

  1.1 成员内部类

      成员内部类,就如同成员一样存在一个类中,该内部类可以直接访问外部类成员和方法,但是外部类不能使用内部类方法或者属性。

      成员内部类访问外部类属性或方法的方式: 外部类名.this.成员名/方法名

      成员内部类声明方式: (假设外部类叫Outer 内部类叫Inner)  Outer.Inner inner = new Outer().new Inner();

 1 public class TestInnerClass {
 2     private String name;  //外部类属性
 3     private int age;
 4
 5
 6     class InnerClass{ //内部类以成员的方式存在外部类中
 7         public void test() {
 8             TestInnerClass.this.name = "张三";  //内部类修改外部类值
 9         }
10
11         public void print() {
12             System.out.println(TestInnerClass.this.name);
13         }
14     }
15
16     public static void main(String[] args) {
17         //声明一个内部类对象
18         TestInnerClass.InnerClass inner = new TestInnerClass().new InnerClass();
19         inner.test();
20         inner.print(); //张三
21     }
22
23 }

  1.2 静态内部类

      顾名思义,静态内部类就是以外部类静态成员的方式存在在一个类中 该内部类不依靠外部类对象(这一点与成员内部类不同!)

      同理,静态内部类可以访问外部类的静态成员或方法

      声明一个静态内部类的方式:  (假设外部类叫Outer 内部类叫Inner) Outer.Inner inner = new Outer().Inner();

      

 1 public class TestInnerClass {
 2     private static String name;  //外部类属性
 3     private int age;
 4
 5
 6     static class InnerClass{ //内部类以成员的方式存在外部类中
 7         public void test() {
 8             TestInnerClass.name = "张三";  //内部类修改外部类值
 9         }
10
11         public void print() {
12             System.out.println(TestInnerClass.name);
13         }
14     }
15
16     public static void main(String[] args) {
17         //声明一个内部类对象
18         TestInnerClass.InnerClass inner = new TestInnerClass.InnerClass();
19         inner.test();
20         inner.print(); //张三
21     }
22
23 }

2.匿名内部类

    匿名内部类,实际上就是隐式的继承了一个接口或者抽象类,并实现该接口或抽象类的方法。

    注意:匿名内部类是不能有构造函数的,这也就决定了每一个匿名内部类是只会用一次的。同时匿名内部类是不能存在任何静态变量或方法的。如果内部类想调用外部变量 则外部变量必须是final的。

    语法  new 接口/抽象类 {  类体实现  }.调用方法()。

interface Test{
    public void print();
}

public class TestNoName {
    public static void main(String[] args) {

        new Test() {

            @Override
            public void print() {
                // TODO Auto-generated method stub
                System.out.println("我是一个接口的匿名抽象类方法");
            }
        }.print();

    }
}

3.局部内部类

    局部内部类就是方法内部的内部类,基本不使用,这里不介绍,请大家自行了解。

4.lambda表达式

    lambda表达式时java8中一个重要的特性,虽然看起来非常高大上,实际上只是java的一个语法糖,最后还是由我们的编译器编译成正常的代码,不过对于程序员来说编写代码会更轻松,代码会更简洁。

    基本语法:(params) ->  expression   或者  (params) -> {语句;}

// 1. 不需要参数,返回值为 5
() -> 5  

// 2. 接收一个参数(数字类型),返回其2倍的值
x -> 2 * x  

// 3. 接受2个参数(数字),并返回他们的差值
(x, y) -> x – y  

// 4. 接收2个int型整数,返回他们的和
(int x, int y) -> x + y  

// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
(String s) -> System.out.print(s)

    一些例子:

    

String[] atp = {"Rafael Nadal", "Novak Djokovic",
       "Stanislas Wawrinka",
       "David Ferrer","Roger Federer",
       "Andy Murray","Tomas Berdych",
       "Juan Martin Del Potro"};
List<String> players =  Arrays.asList(atp);  

// 以前的循环方式
for (String player : players) {
     System.out.print(player + "; ");
}  

// 使用 lambda 表达式以及函数操作(functional operation)
players.forEach((player) -> System.out.print(player + "; "));
   
// 使用匿名内部类
btn.setOnAction(new EventHandler<ActionEvent>() {
          @Override
          public void handle(ActionEvent event) {
              System.out.println("Hello World!");
          }
    });  

// 或者使用 lambda expression
btn.setOnAction(event -> System.out.println("Hello World!"));
// 1.1使用匿名内部类
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello world !");
    }
}).start();  

// 1.2使用 lambda expression
new Thread(() -> System.out.println("Hello world !")).start();  

// 2.1使用匿名内部类
Runnable race1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello world !");
    }
};  

// 2.2使用 lambda expression
Runnable race2 = () -> System.out.println("Hello world !");  

// 直接调用 run 方法(没开新线程哦!)
race1.run();
race2.run();

原文地址:https://www.cnblogs.com/xiaobai1202/p/10836469.html

时间: 2024-10-03 14:52:31

java-07 内部类、匿名内部类、局部内部类、lambda的相关文章

【java基础】内部类,局部内部类,匿名内部类、静态内部类、接口中的内部类

内部类: 1.定义在一个类中的内部类,内部类的实例化伴随着外围类所定义的方法来构造,内部类对象有外围类的隐式引用,所以内部类可以直接访问外围类的外围类的域,包括私有的,这是内部类的访问特权,所以比常规类功能更加强大. 2.内部类可以对同一个包中的其他类隐藏起来,不过可以通过 OuterClass.InnerClass来引用public声明的内部类. 局部内部类: 1.内部类挪到方法内部,与内部类相比,局部内部类不仅可以访问定义他们的外部类,还可以并且仅可以访问声明为final的局部变量. 2.类

Java内部类:局部内部类(三)

Java内部类分为4个部分进行阐述,分别为概览.成员内部类.局部内部类和匿名内部类. 在本文中是Java内部类的局部内部类,主要讲局部内部类的概念和在使用局部内部的过程中,需要注意的一个细节. 1.局部内部类的概念 在一个类的方法内部定义另外一个类,那么另外一个类就称作为局部内部类. class OutterClass { void test() { class InnerClass//局部内部类 { } } } 在上述代码中,InnerClass定义在OutterClass的test方法的内部

java 第42节 局部内部类

2016-06-30 package com.java1995; /** * 内部测试类 * @author Administrator * */ public class TestInner { public static void main(String[] args) { Outer o=new Outer(); OutI oi=o.eat(1); } } class Outer{ private String name; /** * 局部内部类 * 在类的局部位置进行定义的类叫局部内部类

静态非静态内部类匿名内部类局部内部类

内部类有静态内部类,静态内部类,匿名内部类,局部内部类 (1)非静态内部类 直接在类的内部定义的类就是非静态内部类,如下 public class Test { public static void main(String[] args) { Outer.Inner c1=new Outer().new Inner(); c1.Print(); } } class Outer{ private int temp=10; class Inner{ private int temp=100; pub

java中什么是局部内部类Local inner class?

5.局部内部类Local inner class  (视频下载) (全部书籍) 马克-to-win:什么叫局部内部类?内部类声明位置:1.它的外部类的范围之内.2.在几个程序块的范围之内.例如,由方法定义的块中或甚至在for循环体内部.局部内部类有什么意义?意义就是:你希望这个类只被解决某个问题用,任何其他人,其他地方都不能用它.就像临时变量一样.马克-to-win:生活中百年不遇我们去海边玩,专门裁出一块布来铺在沙滩上, 但这块布干什么别的事都不合适,就属于这种情况. 例2.5---本章源码

内部类之局部内部类

一.位置 定义在代码块里和方法里的类 二.结构: 类:不能被访问修饰符修饰 属性:能被访问修饰符修饰,不能被sttaic修饰 方法:能被访问修饰符修饰,不能被static修饰 三.内部类访问外部类 在普通方法里的内部类可以访问外部类的全部成员 在静态方法里的内部类只能访问外部类的类成员 四.外部类访问内部类 在外部类中不能实例化内部类对象,内部类对象只能在该方法中实例化,外部类只能调用该方法 五.局部内部类只能访问final修饰的局部变量 根本原因:内部类和局部变量的生命周期不同导致的 内部类是

Java中的匿名内部类及内部类的二三事

匿名内部类适合创建那些只需要使用一次的类,它的语法有些奇怪,创建匿名内部类会立即创建一个该类的实例,这个类定义立即消失,且不能重复使用. 定义匿名类的格式如下: new 实现接口() |父类构造器(实参列表){ //匿名内部类的类体部分 } 从定义来看,匿名内部类必须继承一个父类,或者实现一个接口,但是最多只能继承一个父类或者实现一个接口. 关于匿名内部类,还有如下两条规则: 匿名内部类不能是抽象类,因为系统在创建匿名内部类时,会立即创建匿名内部类的对象.因此不允许将匿名内部类定义成抽象类. 匿

黑马程序员——————&gt; 局部内部类&amp;匿名内部类

------- android培训.java培训.期待与您交流! ---------- 如果把一个内部类放在方法里定义,则这个内部类就是一个局部内部类,局部内部类仅在该方法里有效.由于局部内部类不能在外部类的方法以外的地方使用,因此局部内部类也不能使用访问控制符和static修饰符修饰. 对于局部成员而言,不管是局部变量还是局部内部类,它们的上一级程序单元都是方法,而不是类,使用static修饰它们没有任何意义.因此,所有的局部成员都不能使用static修饰.不仅如此,因为局部成员的作用域是所在

java中的包以及内部类的介绍

1:形式参数和返回值的问题(理解)    (1)形式参数:        类名:需要该类的对象        抽象类名:需要该类的子类对象        接口名:需要该接口的实现类对象    (2)返回值类型:        类名:返回的是该类的对象        抽象类名:返回的是该类的子类对象        接口名:返回的是该接口的实现类的对象    (3)链式编程        对象.方法1().方法2().......方法n();                这种用法:其实在方法1()

java中的四种内部类

java中的内部类分为四个: 成员内部类 静态内部类 局部内部类 匿名内部类 1. 成员内部类: 定义在另一个类(外部类)的内部,而且与成员方法和属性平级叫成员内部类,......相当于外部类的非静态方法,如果被static修饰,就变成静态内部类了. )成员内部类中不能存在static关键字,即,不能声明静态属性.静态方法.静态代码块等.[非静态内部类也可以定义静态成员但需要同时有final关键词修饰,静态方法鉴于无法用final修饰,仍必须是在静态内部类 或者非内部类中定义.] )创建成员内部