Java_06 快速入门 Java新特性&Eclipse编程

最新推荐文章于 2024-05-21 19:15:40 发布
最新推荐文章于 2024-05-21 19:15:40 发布
阅读量59 收藏
点赞数 1
分类专栏： Java 文章标签： java 开发语言 Eclipse编码 Java新特性 开发思想
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60786924/article/details/125357821
版权

目录

第一章：Eclipse开发工具

1.2  JDT的使用（重点）

范例1-1：编写Hello类。

范例1-2：定义基础类结构。

范例1-3：输出初始化参数。

1.3  JUnit的使用（重点）

范例1-4：定义一个程序。

范例1-5：编写JUnit测试程序。

第二章：Java新特性

2.1  可变参数

范例2-1：最初的解决方案。

范例2-2：使用可变参数定义方法。

2.2  foreach循环

范例2-3：数组输出。

范例2-4：利用foreach循环实现输出。

2.3  静态导入

范例2-5：传统的做法。

范例2-6：基本使用形式。

范例2-7：静态导入。

2.4  泛型

范例2-8：定义Point类，使用Object作为属性类型。

范例2-9：在Point类里面保存整型数据。

范例2-10：在Point类里面保存浮点型数据。

范例2-11：在Point类里面保存使用字符串数据。

范例2-12：错误的程序。

范例2-13：使用泛型修改Point类。

范例2-14：定义多个泛型。

范例2-14：使用Point类将泛型类型设置为String。

范例2-15：将泛型类型设置为整型（Integer）。

范例2-16：不设置泛型类型。

范例2-17：定义一个支持泛型类型的类。

范例2-18：使用泛型操作。

范例2-19：错误的使用。

范例2-20：使用通配符“?”解决参数传递问题。

范例2-21：定义方法参数时不设置泛型类型。

范例2-22：设置泛型的上限。

范例2-23：设置泛型的下限。

范例2-24：定义泛型接口。

范例2-25：泛型方法定义。

2.5  枚举

范例2-26：定义颜色的枚举类。

范例2-27：利用多例设计模式实现类似枚举的操作。

范例2-28：使用Enum定义的方法。

范例2-29：返回枚举中的全部内容。

范例2-30：扩充枚举功能。

范例2-31：枚举实现接口。

范例2-32：另外一种接口的实现。

范例2-33：定义抽象方法并覆写。

范例2-34：在switch语句上使用枚举。

范例2-35：在类设计结构中使用枚举。

正在上传…重新上传取消2.6  Annotation

范例2-36：准确覆写。

范例2-37：错误的程序。

范例2-38：声明过期操作。

范例2-39：压制多个警告信息。

2.7  接口定义加强

范例2-40：定义普通方法。

范例2-41：定义static方法。

正在上传…重新上传取消2.8  Lamda表达式

范例2-42：Lamda表达式入门操作。

范例2-43：使用匿名内部类操作。

范例2-44：函数式接口。

范例2-45：编写多行语句。

范例2-46：定义有参数有返回值的方法。

范例2-47：直接返回计算结果。

范例2-48：传递可变参数。

2.9  方法引用

范例2-49：引用静态方法，本次将引用在String类里的valueOf()的静态方法（public static String valueOf(int x)）。

范例2-50：普通方法引用，本次引用String类中的toUpperCase()方法（public String toUpper Case()）。

范例2-51：引用特定类的方法。

范例2-52：引用构造方法。

2.10  内建函数式接口

范例2-53：使用功能型函数式接口——接收参数并且返回一个处理结果。本操作将利用Function接口引用，String类“public boolean startsWith(String str)”方法。

范例2-54：消费型接口。消费型接口主要是接收参数但是不返回数据，所以本次映射System.out. println(String str)方法。

范例2-55：供给型接口。供给型接口是不接收任何参数的，所以本次引用String类的toUpperCase()方法（public String toUpperCase()）。

范例2-56：断言型接口。断言型接口主要是进行判断操作，本身需要接收一个参数，同时会返回一个判断结果（boolean型）。本次将引用String类中的equalsIgnoreCase()方法（public boolean equalsIgnoreCase(String str)）。

第一章：Eclipse开发工具

1.2  JDT的使用（重点）

范例1-1：编写Hello类。

package com.yootk.demo;

public class Hello {

public static void main(String[] args) {

System.out.println("更多课程请访问：www.yootk.com");

}

}

范例1-2：定义基础类结构。

class Book {

private String title ;

private double price ;

}

范例1-3：输出初始化参数。

package com.yootk.demo;

public class InitParameter {

public static void main(String[] args) {

for (int x = 0 ; x < args.length ; x ++) {

System.out.println(args[x]) ;

}

}

}

1.3  JUnit的使用（重点）

范例1-4：定义一个程序。

package com.yootk.util;

public class MyMath {

public static int div(int x, int y) throws Exception {

return x / y;

}

}

范例1-5：编写JUnit测试程序。

package cn.mldn.test;

import org.junit.Test;

import cn.mldn.util.MyMath;

import junit.framework.TestCase;

public class MyMathTest {

@Test

public void testDiv() {

try {

TestCase.assertEquals(MyMath.div(10, 2), 5);

} catch (Exception e) {

e.printStackTrace();

}

}

}

第二章：Java新特性

2.1  可变参数

范例2-1：最初的解决方案。

package com.yootk.demo;

public class TestDemo {

public static void main(String[] args) {

System.out.println(add(new int[]{1,2,3})); // 传递3个整型数据

System.out.println(add(new int[]{10,20})); // 传递2个整型数据

}

/**

 * 实现任意多个整型数据的相加操作

 * @param data 由于要接收多个整型数据，所以使用数组完成接收

 * @return 多个整型数据的累加结果

 */

public static int add(int [] data) {

int sum = 0 ;

for (int x = 0 ; x < data.length ; x ++) {

sum += data[x] ;

}

return sum ;

}

}

范例2-2：使用可变参数定义方法。

package com.yootk.demo;

public class TestDemo {

public static void main(String[] args) {

// 可变参数支持接收数组

System.out.println(add(new int[]{1,2,3})); // 传递3个整型数据

System.out.println(add(new int[]{10,20})); // 传递2个整型数据

// 或者使用“,”区分不同的参数，接收的时候还是数组

System.out.println(add(1,2,3)); // 传递3个参数

System.out.println(add(10,20)); // 传递2个参数

System.out.println(add()); // 不传递参数

}

/**

 * 实现任意多个整型数据的相加操作

 * @param data 由于要接收多个整型数据，所以使用数组完成接收

 * @return 多个整型数据的累加结果

 */

public static int add(int ... data) {

int sum = 0 ;

for (int x = 0 ; x < data.length ; x ++) {

sum += data[x] ;

}

return sum ;

}

}

2.2  foreach循环

范例2-3：数组输出。

package com.yootk.demo;

public class TestDemo {

public static void main(String[] args) {

int data[] = new int[] { 1, 2, 3, 4, 5 }; // 定义数组

for (int x = 0; x < data.length; x++) { // 循环输出数组

System.out.print(data[x] + "、");

}

}

}

范例2-4：利用foreach循环实现输出。

package com.yootk.demo;

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

int data[] = new int[] { 1, 2, 3, 4, 5 }; // 定义数组

for (int x : data) { // 循环次数由数组长度决定

// 每一次循环实际上都表示数组的角标增长，会取得每一个数组的内容，并且将其设置给x

System.out.println(x + "、"); // x就是每一个数组元素的内容

}

}

}

2.3  静态导入

范例2-5：传统的做法。

package com.yootk.util;

public class MyMath {

public static int add(int x,int y) {

return x + y ;

}

public static int div(int x,int y) {

return x / y ;

}

}

范例2-6：基本使用形式。

package com.yootk.demo;

import com.yootk.util.MyMath;

public class TestDemo {

public static void main(String[] args) {

System.out.println("加法操作：" + MyMath.add(10, 20));

System.out.println("除法操作：" + MyMath.div(10, 2));

}

}

范例2-7：静态导入。

package com.yootk.demo;

// 将MyMath类中的全部static方法导入，这些方法就好比在主类中定义的static方法一样

import static com.yootk.util.MyMath.*;

public class TestDemo {

public static void main(String[] args) {

// 直接使用方法名称访问

System.out.println("加法操作：" + add(10, 20));

System.out.println("除法操作：" + div(10, 2));

}

}

2.4  泛型

范例2-8：定义Point类，使用Object作为属性类型。

class Point { // 定义坐标

private Object x ;  // 可以保存任意数据

private Object y ;  // 可以保存任意数据

public void setX(Object x) {

this.x = x;

}

public void setY(Object y) {

this.y = y;

}

public Object getX() {

return x;

}

public Object getY() {

return y;

}

}

范例2-9：在Point类里面保存整型数据。

public class TestDemo {

public static void main(String[] args) {

// 第一步：根据需要设置数据，假设此时的作用是传递坐标

Point p = new Point() ; // 实例化Point类数据

p.setX(10); // 设置坐标数据

p.setY(20); // 设置坐标数据

// 第二步：根据设置好的坐标取出数据进行操作

int x = (Integer) p.getX(); // 取出坐标数据

int y = (Integer) p.getY(); // 取出坐标数据

System.out.println("x坐标：" + x + "，y坐标：" + y);

}

}

范例2-10：在Point类里面保存浮点型数据。

public class TestDemo {

public static void main(String[] args) {

// 第一步：根据需要设置数据，假设此时的作用是传递坐标

Point p = new Point() ; // 实例化Point类数据

p.setX(10.2); // 设置坐标数据

p.setY(20.3); // 设置坐标数据

// 第二步：根据设置好的坐标取出数据进行操作

double x = (Double) p.getX(); // 取出坐标数据

double y = (Double) p.getY(); // 取出坐标数据

System.out.println("x坐标：" + x + "，y坐标：" + y);

}

}

范例2-11：在Point类里面保存使用字符串数据。

public class TestDemo {

public static void main(String[] args) {

// 第一步：根据需要设置数据，假设此时的作用是传递坐标

Point p = new Point() ; // 实例化Point类数据

p.setX("东经100度"); // 设置坐标数据

p.setY("北纬20度"); // 设置坐标数据

// 第二步：根据设置好的坐标取出数据进行操作

String x = (String) p.getX(); // 取出坐标数据

String y = (String) p.getY(); // 取出坐标数据

System.out.println("x坐标：" + x + "，y坐标：" + y);

}

}

范例2-12：错误的程序。

public class TestDemo {

public static void main(String[] args) {

// 第一步：根据需要设置数据，假设此时的作用是传递坐标

Point p = new Point() ; // 实例化Point类数据

p.setX("东经100度"); // 设置坐标数据

p.setY(10) ; // 设置坐标数据，数据错误

// 第二步：根据设置好的坐标取出数据进行操作

String x = (String) p.getX(); // 取出坐标数据

String y = (String) p.getY(); // 取出坐标数据

System.out.println("x坐标：" + x + "，y坐标：" + y);

}

}

范例2-13：使用泛型修改Point类。

package com.yootk.demo;

// 此时设置的T在Point类定义上只表示一个标记，在使用时需要为其设置具体的类型

class Point<T> { // 定义坐标，Type = 简写T，是一个类型标记

private T x ; // 此属性的类型不知道，由Point类使用时动态决定

private T y ; // 此属性的类型不知道，由Point类使用时动态决定

public void setX(T x) {

this.x = x;

}

public void setY(T y) {

this.y = y;

}

public T getX() {

return x;

}

public T getY() {

return y;

}

}

范例2-14：定义多个泛型。

class Point<P, R> {

public R fun(P p) {

return null ;

}

}

范例2-14：使用Point类将泛型类型设置为String。

public class TestDemo {

public static void main(String[] args) {

// 第一步：根据需要设置数据，假设此时的作用是传递坐标

Point<String> p = new Point<String>()  ; // 实例化Point类数据，设置泛型类型为String

p.setX("东经100度"); // 设置坐标数据

p.setY("北纬20度") ; // 设置坐标数据

// 第二步：根据设置好的坐标取出数据进行操作

String x = p.getX();  // 取出坐标数据，不再需要强制转换

String y = p.getY(); // 取出坐标数据，不再需要强制转换

System.out.println("x坐标：" + x + "，y坐标：" + y);

}

}

范例2-15：将泛型类型设置为整型（Integer）。

public class TestDemo {

public static void main(String[] args) {

// 第一步：根据需要设置数据，假设此时的作用是传递坐标

Point<Integer> p = new Point<Integer>()  ; // 实例化Point类数据，设置泛型类型为String

p.setX(10); // 设置坐标数据

p.setY(20) ; // 设置坐标数据

// 第二步：根据设置好的坐标取出数据进行操作

int x = p.getX(); // 取出坐标数据，不再需要强制转换

int y = p.getY(); // 取出坐标数据，不再需要强制转换

System.out.println("x坐标：" + x + "，y坐标：" + y);

}

}

范例2-16：不设置泛型类型。

public class TestDemo {

public static void main(String[] args) {

// 第一步：根据需要设置数据，假设此时的作用是传递坐标

Point p = new Point() ; // 将使用Object类型描述泛型

p.setX(10); // 设置坐标数据，向上转型为Object

p.setY(20) ; // 设置坐标数据，向上转型为Object

// 第二步：根据设置好的坐标取出数据进行操作

Integer x = (Integer) p.getX();

Integer y = (Integer) p.getY();

System.out.println("x坐标：" + x + "，y坐标：" + y);

}

}

范例2-17：定义一个支持泛型类型的类。

package com.yootk.demo;

class Message<T> { // 类上使用泛型

private T msg;

public void setMsg(T msg) {

this.msg = msg;

}

public T getMsg() {

return msg;

}

}

范例2-18：使用泛型操作。

package com.yootk.demo;

public class TestDemo {

public static void main(String[] args) {

Message<String> m = new Message<String>();

m.setMsg("www.yootk.com"); // 设置内容

fun(m); // 引用传递

}

/**

 * 接收Message类对象，并且调用getter方法输出类中的msg属性内容

 * @param temp 接收Message类对象的引用传递，此处设置的泛型类型为String

 */

public static void fun(Message<String> temp) {

System.out.println(temp.getMsg());

}

}

范例2-19：错误的使用。

public class TestDemo {

public static void main(String[] args) {

Message<Integer> m = new Message<Integer>();

m.setMsg(30); // 设置内容

fun(m);  // 程序错误，因为参数的泛型类型是String

}

public static void fun(Message<String> temp) {

System.out.println(temp.getMsg());

}

}

范例2-20：使用通配符“?”解决参数传递问题。

public class TestDemo {

public static void main(String[] args) {

Message<Integer> m1 = new Message<Integer>();

Message<String> m2 = new Message<String>();

m1.setMsg(100); // 设置属性内容

m2.setMsg("www.yootk.com"); // 设置属性内容

fun(m1); // 引用传递

fun(m2); // 引用传递

}

public static void fun(Message<?> temp) { // 不能设置，但是可以取出

System.out.println(temp.getMsg());

}

}

范例2-21：定义方法参数时不设置泛型类型。

public class TestDemo {

public static void main(String[] args) {

Message<Integer> m1 = new Message<Integer>();

Message<String> m2 = new Message<String>();

m1.setMsg(100);

m2.setMsg("www.yootk.com");

fun(m1);

fun(m2);

}

public static void fun(Message temp) {

// 随意修改属性内容，逻辑错误

temp.setMsg("魔乐科技软件学院：www.mldn.cn"); 

System.out.println(temp.getMsg());

}

}

范例2-22：设置泛型的上限。

package com.yootk.demo;

class Message<T extends Number> { // 设置泛型上限，只能够是Number或Number子类

private T msg;

public void setMsg(T msg) {

this.msg = msg;

}

public T getMsg() {

return msg;

}

}

public class TestDemo {

public static void main(String[] args) {

Message<Integer> m1 = new Message<Integer>(); // Integer是Number子类

m1.setMsg(100);

fun(m1); // 引用传递

}

public static void fun(Message<? extends Number> temp) { // 定义泛型上限

System.out.println(temp.getMsg());

}

}

范例2-23：设置泛型的下限。

package com.yootk.demo;

class Message<T> { // 定义泛型

private T msg;

public void setMsg(T msg) {

this.msg = msg;

}

public T getMsg() {

return msg;

}

}

public class TestDemo {

public static void main(String[] args) {

Message<String> m1 = new Message<String>();

m1.setMsg("更多课程请访问：www.yootk.com"); // 设置属性内容

fun(m1); // 引用传递

}

public static void fun(Message<? super String> temp) { // 定义泛型下限

System.out.println(temp.getMsg());

}

}

范例2-24：定义泛型接口。

package com.yootk.demo;

/**

 * 定义泛型接口，由于类与接口命名标准相同，为了区分出类与接口，在接口前加上字母“I”，例如：IMessage

 * 如果定义抽象类，则可以在前面加上Abstract，例如：AbstractMessage

 * @author YOOTK

 * @param <T> print()方法使用的泛型类型

 */

interface IMessage<T> { // 定义泛型接口

public void print(T t);

}

范例2-25：泛型方法定义。

package com.yootk.demo;

public class TestDemo {

public static void main(String[] args) {

String str = fun("www.yootk.com"); // 泛型类型为String

System.out.println(str.length()); // 计算长度

}

/**

 * 此方法为泛型方法，T的类型由传入的参数类型决定

 * 必须在方法返回值类型前明确定义泛型标记

 * @param t 参数类型，同时也决定了返回值类型

 * @return 直接返回设置进来的内容

 */

public static <T> T fun(T t) {

return t;

}

}

2.5  枚举

范例2-26：定义颜色的枚举类。

package com.yootk.demo;

enum Color { // 定义枚举类

RED, GREEN, BLUE; // 表示此处为实例化对象

}

public class TestDemo {

public static void main(String[] args) {

Color red = Color.RED; // 直接取得枚举对象

System.out.println(red);

}

}

范例2-27：利用多例设计模式实现类似枚举的操作。

package com.yootk.demo;

class Color {

private String title;

private static final Color RED = new Color("红色");

private static final Color GREEN = new Color("绿色");

private static final Color BLUE = new Color("蓝色");

private Color(String title) {

this.title = title;

}

public static Color getInstance(int ch) {

switch (ch) {

case 1:

return RED;

case 2:

return GREEN;

case 3:

return BLUE;

default:

return null;

}

}

public String toString() {

return this.title;

}

}

public class TestDemo {

public static void main(String[] args) {

Color red = Color.getInstance(1);

System.out.println(red);

}

}

范例2-28：使用Enum定义的方法。

package com.yootk.demo;

enum Color { // 定义枚举类

RED, GREEN, BLUE; // 表示此处为实例化对象

}

public class TestDemo {

public static void main(String[] args) {

Color red = Color.RED; // 直接取得枚举对象

System.out.println("枚举对象序号：" + red.ordinal());

System.out.println("枚举对象名称：" + red.name());

}

}

范例2-29：返回枚举中的全部内容。

package com.yootk.demo;

enum Color { // 定义枚举类

RED, GREEN, BLUE; // 表示此处为实例化对象

}

public class TestDemo {

public static void main(String[] args) {

for(Color c : Color.values()) {

System.out.println(c.ordinal() + " - " + c.name());

}

}

}

范例2-30：扩充枚举功能。

package com.yootk.demo;

enum Color {

RED("红色"), GREEN("绿色"), BLUE("蓝色"); // 定义枚举对象，必须写在首行

private String title; // 属性

private Color(String title) { // 构造方法，不能使用public声明

this.title = title;

}

public String toString() { // 覆写toString()方法

return this.title;

}

}

public class TestDemo {

public static void main(String[] args) {

for (Color c : Color.values()) { // 取得全部枚举对象

System.out.print(c + "、"); // 直接输出对象调用toString()

}

}

}

范例2-31：枚举实现接口。

package com.yootk.demo;

interface IMessage {

public String getTitle() ;

}

enum Color implements IMessage { // 实现接口

RED("红色"), GREEN("绿色"), BLUE("蓝色"); // 定义枚举对象，都是IMessage接口实例

private String title; // 属性

private Color(String title) { // 构造方法，不能使用public声明

this.title = title;

}

public String getTitle() { // 覆写方法

return this.title ;

}

public String toString() { // 覆写toString()方法

return this.title;

}

}

public class TestDemo {

public static void main(String[] args) {

IMessage msg = Color.RED ; // 实例化接口对象

System.out.println(msg.getTitle());

}

}

范例2-32：另外一种接口的实现。

package com.yootk.demo;

interface IMessage {

public String getTitle() ;

}

enum Color implements IMessage { // 实现接口

RED("红色") { // 适应匿名内部类的方式实现接口

public String getTitle() {

return this + " - red";

}

},

GREEN("绿色") { // 适应匿名内部类的方式实现接口

public String getTitle() {

return this + " - green";

}

},

BLUE("蓝色") { // 适应匿名内部类的方式实现接口

public String getTitle() {

return this + " - blue";

}

};

private String title; // 属性

private Color(String title) { // 构造方法，不能使用public声明

this.title = title;

}

public String toString() { // 覆写toString()方法

return this.title;

}

}

public class TestDemo {

public static void main(String[] args) {

IMessage msg = Color.RED ; // 实例化接口对象

System.out.println(msg.getTitle());

}

}

范例2-33：定义抽象方法并覆写。

package com.yootk.demo;

enum Color {

RED("红色") { // 适应匿名内部类的方式实现接口

public String getTitle() {

return this + " - red";

}

},

GREEN("绿色") { // 适应匿名内部类的方式实现接口

public String getTitle() {

return this + " - green";

}

},

BLUE("蓝色") { // 适应匿名内部类的方式实现接口

public String getTitle() {

return this + " - blue";

}

};

private String title; // 属性

private Color(String title) { // 构造方法，不能使用public声明

this.title = title;

}

public String toString() { // 覆写toString()方法

return this.title;

}

public abstract String getTitle() ; // 定义抽象方法

}

public class TestDemo {

public static void main(String[] args) {

System.out.println(Color.RED.getTitle());

}

}

范例2-34：在switch语句上使用枚举。

package com.yootk.demo;

enum Color {

RED, GREEN, BLUE;

}

public class TestDemo {

public static void main(String[] args) {

Color c = Color.RED;

switch (c) { // 支持枚举判断

case RED: // 判断枚举内容

System.out.println("这是红色！");

break;

case GREEN: // 判断枚举内容

System.out.println("这是绿色！");

break;

case BLUE: // 判断枚举内容

System.out.println("这是蓝色！");

break;

}

}

}

范例2-35：在类设计结构中使用枚举。

package com.yootk.demo;

enum Sex {

MALE("男"),FEMALE("女") ;

private String title ;

private Sex(String title) {

this.title = title ;

}

public String toString() {

return this.title ;

}

}

class Member {

private String name ;

private int age ;

private Sex sex ; // 定义性别属性

public Member(String name,int age,Sex sex) {

this.name = name ;

this.age = age ;

this.sex = sex ;

}

public String toString() {

return "姓名：" + this.name + "，年龄：" + this.age + "，性别：" + this.sex ;

}

}

public class TestDemo {

public static void main(String[] args) {

System.out.println(new Member("李兴华", 36, Sex.MALE));

}

}

2.6  Annotation

范例2-36：准确覆写。

class Book {

@Override // 只要正确进行了覆写，就不会出现编译的语法错误

public String toString() { // 原本打算覆写toString()

return "《名师讲坛 —— Oracle开发实战经典》" ;

}

}

范例2-37：错误的程序。

class Book {

public String tostring() { // 原本打算覆写toString()

return "这是一本书！" ;

}

}

范例2-38：声明过期操作。

package com.yootk.demo;

class Book {

@Deprecated // 此方法为过期操作

public void fun() { // 使用会有警告，但是不会出错

}

}

public class TestDemo {

public static void main(String[] args) {

Book book = new Book();

book.fun(); // 此方法不建议使用

}

}

范例2-39：压制多个警告信息。

package com.yootk.demo;

class Book<T> {

private T title;

public void setTitle(T title) {

this.title = title;

}

public T getTitle() {

return title;

}

}

public class TestDemo {

@SuppressWarnings({ "rawtypes", "unchecked" })

public static void main(String[] args) {

Book book = new Book(); // 没有声明泛型，产生“rawtypes”警告信息

book.setTitle("HELLO"); // 出现警告信息，产生“unchecked”警告信息

}

}

2.7  接口定义加强

范例2-40：定义普通方法。

package com.yootk.demo;

interface IMessage { // 定义接口

public void print(); // 这是一个接口里面原本定义的方法

default void fun() { // 在接口里面定义了一个普通的方法

System.out.println("更多课程请访问：www.yootk.com");

}

}

class MessageImpl implements IMessage {

@Override

public void print() { // 覆写print()方法

System.out.println("魔乐科技软件学院：www.mldn.cn");

}

}

public class TestDemo {

public static void main(String[] args) {

IMessage msg = new MessageImpl();

msg.print(); // 子类已覆写接口方法

msg.fun(); // 此方法是在接口里面直接定义的

}

}

范例2-41：定义static方法。

package com.yootk.demo;

interface IMessage { // 定义接口

public void print(); // 这是一个接口里面原本定义的方法

static void get() {

System.out.println("更多课程请访问：www.yootk.com");

}

}

public class TestDemo {

public static void main(String[] args) {

IMessage.get(); // 直接利用接口调用静态方法

}

}

2.8  Lamda表达式

范例2-42：Lamda表达式入门操作。

package com.yootk.demo;

interface IMessage {

public void print() ;

}

public class TestDemo {

public static void main(String[] args) {

// 此处为Lamda表达式，没有任何输入参数，只是进行输出操作

fun(() -> System.out.println("更多课程请访问：www.yootk.com"));

}

public static void fun(IMessage msg) {

msg.print() ;

}

}

范例2-43：使用匿名内部类操作。

package com.yootk.demo;

interface IMessage {

public void print() ;

}

public class TestDemo {

public static void main(String[] args) {

fun(new IMessage() { // 等价于Lamda表达式定义

@Override

public void print() {

System.out.println("更多课程请访问：www.yootk.com") ;

}

});

}

public static void fun(IMessage msg) {

msg.print() ;

}

}

范例2-44：函数式接口。

@FunctionalInterface

interface IMessage {

public void print() ;

}

范例2-45：编写多行语句。

package com.yootk.demo;

@FunctionalInterface

interface IMessage {

public void print() ;

}

public class TestDemo {

public static void main(String[] args) {

String info = "魔乐科技软件学院：www.mldn.cn" ;

fun(() -> {

System.out.println("更多课程请访问：www.yootk.com") ;

System.out.println(info) ; // 输出方法中的变量

});

}

public static void fun(IMessage msg) {

msg.print() ;

}

}

范例2-46：定义有参数有返回值的方法。

package com.yootk.demo;

@FunctionalInterface

interface IMessage {

public int add(int x, int y);

}

public class TestDemo {

public static void main(String[] args) {

fun((s1, s2) -> { // 传递两个参数，此处只是一个参数标记

return s1 + s2;

});

}

public static void fun(IMessage msg) {

System.out.println(msg.add(10, 20));

}

}

范例2-47：直接返回计算结果。

public static void main(String[] args) {

// 直接返回两个参数的计算结果，省略return

fun((s1, s2) -> s1 + s2);

}

范例2-48：传递可变参数。

package com.yootk.demo;

@FunctionalInterface

interface IMessage {

public int add(int ... args);

static int sum(int ... args) { // 此方法可以由接口名称直接调用

int sum = 0;

for (int temp : args) {

sum += temp;

}

return sum;

}

}

public class TestDemo {

public static void main(String[] args) {

// 在Lamda表达式中直接调用接口里定义的静态方法

fun((int... param) -> IMessage.sum(param));

}

public static void fun(IMessage msg) {

System.out.println(msg.add(10, 20, 30)); // 传递可变参数

}

}

2.9  方法引用

范例2-49：引用静态方法，本次将引用在String类里的valueOf()的静态方法（public static String valueOf(int x)）。

package com.yootk.demo;

/**

 * 实现方法的引用接口

 * @param <P> 引用方法的参数类型

 * @param <R> 引用方法的返回类型

 */

@FunctionalInterface

interface IMessage<P, R> {

/**

 * 此处为方法引用后的名字

 * @param p 参数类型

 * @return 返回指定类型的数据

 */

public R zhuanhuan(P p);

}

public class TestDemo {

public static void main(String[] args) {

// 将String.valueOf()方法变为IMessage接口里的zhuanhuan()方法

// valueOf()方法可以接收int型数据，返回String型数据

IMessage<Integer, String> msg = String::valueOf;

String str = msg.zhuanhuan(1000); // 调用引用方法进行操作

System.out.println(str.replaceAll("0", "9"));

}

}

范例2-50：普通方法引用，本次引用String类中的toUpperCase()方法（public String toUpper Case()）。

package com.yootk.demo;

/**

 * 实现方法的引用接口

 * @param <P> 引用方法的参数类型

 * @param <R> 引用方法的返回类型

 */

@FunctionalInterface

interface IMessage<R> {

public R upper() ;

}

public class TestDemo {

public static void main(String[] args) {

// String类的toUpperCase()定义：public String toUpperCase()

// 此方法没有参数，但是有返回值，并且这个方法一定要在有实例化对象的情况下才可以调用

//“yootk”字符串是String类的实例化对象，所以可以直接调用toUpperCase()方法

// 将toUpperCase()函数的应用交给了IMessage接口

IMessage<String> msg = "yootk" :: toUpperCase ;

String str = msg.upper() ; // 相当于“"yootk".toUpperCase()”

System.out.println(str);

}

}

范例2-51：引用特定类的方法。

package com.yootk.demo;

@FunctionalInterface

interface IMessage<P> {

public int compare(P p1,P p2) ;

}

public class TestDemo {

public static void main(String[] args) {

IMessage<String> msg = String :: compareTo ; // 引用String类的普通方法

// 传递调用的参数，形式为："A".compareTo("B")

System.out.println(msg.compare("A", "B"));

}

}

范例2-52：引用构造方法。

package com.yootk.demo;

@FunctionalInterface

interface IMessage<C> {

public C create(String t, double p); // 引用构造方法

}

class Book {

private String title;

private double price;

public Book(String title, double price) { // 有两个参数的构造

this.title = title;

this.price = price;

}

@Override

public String toString() {

return "书名：" + this.title + "，价格：" + this.price;

}

}

public class TestDemo {

public static void main(String[] args) {

IMessage<Book> msg = Book::new; // 引用构造方法

// 调用的虽然是create()，但是这个方法引用的是Book类的构造

Book book = msg.create("Java开发实战经典", 79.8);

System.out.println(book);

}

}

2.10  内建函数式接口

范例2-53：使用功能型函数式接口——接收参数并且返回一个处理结果。本操作将利用Function接口引用，String类“public boolean startsWith(String str)”方法。

package com.yootk.demo;

import java.util.function.Function;

public class TestDemo {

public static void main(String[] args) {

Function<String, Boolean> fun = "##yootk"::startsWith;

System.out.println(fun.apply("##")); // 相当于利用对象调用startsWith()

}

}

范例2-54：消费型接口。消费型接口主要是接收参数但是不返回数据，所以本次映射System.out. println(String str)方法。

package com.yootk.demo;

import java.util.function.Consumer;

public class TestDemo {

public static void main(String[] args) {

Consumer<String> cons = System.out::print;

cons.accept("更多课程，请访问：www.yootk.com");

}

}

范例2-55：供给型接口。供给型接口是不接收任何参数的，所以本次引用String类的toUpperCase()方法（public String toUpperCase()）。

package com.yootk.demo;

import java.util.function.Supplier;

public class TestDemo {

public static void main(String[] args) {

Supplier<String> sup = "yootk"::toUpperCase;

System.out.println(sup.get());

}

}

范例2-56：断言型接口。断言型接口主要是进行判断操作，本身需要接收一个参数，同时会返回一个判断结果（boolean型）。本次将引用String类中的equalsIgnoreCase()方法（public boolean equalsIgnoreCase(String str)）。

package com.yootk.demo;

import java.util.function.Predicate;

public class TestDemo {

public static void main(String[] args) {

Predicate<String> pre = "yootk"::equalsIgnoreCase;

System.out.println(pre.test("YOOTK"));

}

}

£轻描～淡写°
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 14万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
Java如何快速入门？Java基础_Java入门
m0_46184557的博客
04-02 4237
小编认为对接触Java的小白来说，最担心的应该就是Java怎么学，都需要掌握哪些内容？今天这篇文章希望能帮助大家快速入门Java，少走弯路！ 一、作为刚接触Java的新手，肯定要先了解Java的基础。 Java 基本语法、Java 平台应用、Java的核心概念：JVM、JDK、JRE以及Java面向对象思想，同时要会学到如何在系统中搭建Java开发环境，以及如何利用第三方工具进行Java程序的开发。 学习Java语言最重要的是：学习步骤和方法 只要找到适合自己的学习方式，找到适合自己现阶段的学习资料
Java编程入门：使用Eclipse快捷键
qq_39816406的博客
03-30 1799
文章目录一、使用Eclipse编写Java快捷键二、代码示例总结 一、使用Eclipse编写Java快捷键 Eclipse中的快捷键： 1.补全代码的声明：alt + / 2.快速修复: ctrl + 1 3.批量导包：ctrl + shift + o 4.使用单行注释：ctrl + / 5.使用多行注释： ctrl + shift + / 6.取消多行注释：ctrl + shift + \ 7.复制指定行的代码：ctrl + alt + down 或 ctrl + alt + up 8.删除指定行的代
新手小白入门编程第3讲 JAVA入门案例
程序媛泡泡的博客
03-31 4万+
1 HelloWorld案例 1.1 工作空间设置 工作空间就是一个文件夹,用来保存我们所有的开发文件和代码等等. 工作空间也是可以切换的,但是切换了工作空间,我们对于eclipse的设置就重置了. 后续我们自己写的代码可以去这个位置找到.可以如下图,选择工作空间的存放目录 1.2 eclipse设置java视图 设置JAVA视图是为了开发时更加方便 2 完成第一个Java案例HelloWorld 2.1 创建java工程day01 2.2 创建包cn.tedu.hello 2.3 创建类Hell
Java学习路线总结，搬砖工逆袭Java架构师
热门推荐
学Java，找哪吒
09-07 24万+
定期分享Java硬核技术干货、分享Java学习路线、分享Java经典面试题
java1.8新特性入门级讲解
我认不到你的博客
10-20 4115
java1.8引入了许多的特性，在此我们主要讨论一下几点： - **接口静态方法** - **接口默认方法** ： 默认方法就是一个在接口里面有了一个或多个实现的方法。 - **函数式接口**： 一个在接口只有一个待实现的方法。 （重要） - **Lambda 表达式**： Lambda 允许把函数作为一个方法的参数（函数作为参数传递到方法中）。 （重要） - **Stream API**： 新添加的Stream API（java.util.stream） 把真正的函数式
java fx 教程_JavaFX快速入门
weixin_35511255的博客
02-24 2237
1- 前提条件在本文中，将学习如何在 Eclipse IDE 开发和执行JavaFX编程。e(fx)eclipsee(fx)eclipse是一组工具和必要的库，它们帮助您执行JavaFX编程，确保您已经作为插件将其安装在eclipse上了。 如果未安装e(fx)eclipse，可以在以下链接查看安装指南：JavaFX Scene BuilderJavaFX Scene Builder是一种可视化设...
JAVA编程入门
weixin_47698996的博客
10-29 1360
程序 程序=算法+数据结构 用户使用编程语言实现问题域到解域的映射，细节描述算法 1.汇编语言-贴近于硬件设备 2.高级语言-C#、Java-贴近于自然语言-需要编译过程将高级语言所编写的程序转换为计算机能够识别的01码 3.中级语言-C JAVA 一种编程语言、一种开发环境、一种应用环境、一种部署环境 Java是一种可以撰写跨平台应用程序的面向对象的程序设计语言。Java技术具有卓越的通用性、高效性、平台移植性和安全性(以牺牲执行效率为代价换取了高安全性)，广泛应用于PC、数据中心、游戏控制台、科学超级计
基于Java swing+mysql+eclipse的【图书管理系统】
杨明金的博客
07-19 18万+
一、效果演示： 主要功能： ①基本数据维护： 图书类别管理 >> 图书类别添加、图书类别维护 图书管理 >> 图书添加、图书维护 ②关于我们 1、登录界面 2、主界面： 3、图书类别维护 4、图书类别添加 5、图书维护 6、图书添加 7、关于我们 可全部缩小到左下角 二、核心代码： 1、Util包 【存放数据库连接工具】 ① DBTool（数据库连接工具类） package cn.ac.azure.util; import java.io.IOException
java fx详解_JavaFX快速入门
weixin_35432846的博客
03-06 2185
1- 前提条件在本文中，将学习如何在 Eclipse IDE 开发和执行JavaFX编程。e(fx)eclipsee(fx)eclipse是一组工具和必要的库，它们帮助您执行JavaFX编程，确保您已经作为插件将其安装在eclipse上了。 如果未安装e(fx)eclipse，可以在以下链接查看安装指南：JavaFX Scene BuilderJavaFX Scene Builder是一种可视化设...
struts2hello.rar_Java编程_Java_
08-12
struts2入门工程，在eclipse下已成功调试
Java编程入门文档教程合集
07-22
【】Java入门深入理解嵌套类和内部类【】Java和JSP编程的六个常见问题【】JAVA基础知识【】Java编程语言.（第三版）【】Java设计模式-图解-附代码【】第1章【】编程必备Eclipse快捷键资源截图： 资源太大，传百度...
完整版 杭州电子科技大学JAVA语言程序设计 JAVA_08 AWT图形界面编程 JFC Swing （共22页）.ppt
12-26
完整版 杭州电子科技大学JAVA语言程序设计 JAVA_06 异常处理Exceptions（共31页）.ppt 完整版 杭州电子科技大学JAVA语言程序设计 JAVA_07 IO输入输出（共30页）.ppt 完整版 杭州电子科技大学JAVA语言程序设计 JAVA_...
完整版 杭州电子科技大学JAVA语言程序设计 JAVA_13 JDBC（共15页）.ppt
12-26
完整版 杭州电子科技大学JAVA语言程序设计 JAVA_06 异常处理Exceptions（共31页）.ppt 完整版 杭州电子科技大学JAVA语言程序设计 JAVA_07 IO输入输出（共30页）.ppt 完整版 杭州电子科技大学JAVA语言程序设计 JAVA_...
完整版 杭州电子科技大学JAVA语言程序设计 JAVA_03 JAVA语言基础（共57页）.ppt
12-26
完整版 杭州电子科技大学JAVA语言程序设计 JAVA_06 异常处理Exceptions（共31页）.ppt 完整版 杭州电子科技大学JAVA语言程序设计 JAVA_07 IO输入输出（共30页）.ppt 完整版 杭州电子科技大学JAVA语言程序设计 JAVA_...
android高斯模糊填充imageview背景
最新发布
cf8833的博客
05-21 211
说明：最近碰到一个需求，安卓app显示在线的url图片，然后imageview没占满的部分，使用该图片的模糊背景填充。
docker中安装jenkins，并在node和cloud上跑通基于源码控制SCM的pipeline
qq_29022265的博客
05-19 1182
从安装jenkins到创建jenkins的node和cloud，最后再将scm和FreeStyle两种流水线跑通。
分布式锁2-Zookeeper分布式锁实战
qq_43676797的博客
05-19 336
使用curator操作Zookeeper进行实战；：Apache Curator包含一套高级API框架和工具类，它 是Apache ZooKeeper 的Java 客户端库。
java数据结构与算法(验证二叉搜索树)
磐门的博客
05-17 425
节点返回空为ture,节点的值不在对应数据大小范围内返回false。将验证二叉搜索树计算同样可以转换为相同子问题，所以比较适合用递归。node为root的左节点时，max更新为root.val。node为root的右节点时，min更新为root.val。
java编程实战宝典
02-04
该书内容丰富，深入浅出，既适合初学者快速入门，也适合有一定经验的开发者进一步提高。无论是想系统学习Java编程知识，还是想巩固和扩展已有技能，都可以通过《Java编程实战宝典》获得帮助。 此外，书中还介绍了...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值