Java基础回顾2

已于 2022-05-22 20:35:49 修改
阅读量184 收藏
点赞数
文章标签： java 开发语言
于 2022-05-22 13:15:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_69015220/article/details/124486730
版权

Java基础 第二阶段

在这里插入图片描述

一 、面向对象

面向对象的三大基本特征：
封装
继承
多态
面向对象的编程思想就是把事物看作一个整体，从事物的特征（属性）和行为（方法）两个方面进行描述。
面向对象的过程就是找对象、建立对象、使用对象、维护对象的关系的过程

二 、封装

封装的优点

  1. 良好的封装能够减少耦合。

  2. 类内部的结构可以自由修改。

  3. 可以对成员变量进行更精确的控制。

  4. 隐藏信息，实现细节。

三 、访问修饰符

1、public

1、当一个类被声明为 public 时，它就具有了被其他包中的类访问的可能性，只要包中的其他类在程序中使用 import 语句引入 public 类，就可以访问和引用这个类。

2、类中被设定为 public 的方法是这个类对外的接口部分，避免了程序的其他部分直接去操作类内的数据，实际就是数据封装思想的体现。每个 Java 程序的主类都必须是 public 类，也是基于相同的原因。

2、protected

类访问权限protected，

用保护访问控制符 protected 修饰的类成员可以被三种类所访问：
1、该类自身
2、与它在同一个包中的其他类
3、在其他包中的该类的子类。
protected 修饰符的主要作用，是允许其他包中它的子类来访问父类的特定属性和方法，否则可以使用默认访问控制符。

3、default

包的访问权限default，

顾名思义只要在同一个包内便可使用。
如果一个类没有访问控制符，说明它具有默认的访问控制特性。这种默认的访问控制权规定，该类只能被同一个包中的类访问和引用，而不能被其他包中的类使用，即使其他包中有该类的子类

4、private

该类自身的方法访问和修改

用 private 修饰的类成员，只能被该类自身的方法访问和修改，而不能被任何其他类（包括该类的子类）访问和引用。因此，private 修饰符具有最高的保护级别。实现Java封装的步骤

  1. 修改属性的可见性来限制对属性的访问（一般限制为private），例如：

        public class Student {
     private String name;//姓名
     private int age;//年龄
     private int sex;//性别


package 动物类;
 
public class Pet {
//属性设置为私有的
	private String name;
	private String color;
	private int leggs;
	public Pet(String name,String color,int leggs) {
		this.color=color;
		this.leggs=leggs;
		this.name=name;
//使用get、set方法
	}
	public void setName(String name) {
		this.name = name;
	}
	public void getName() {
		return;
	}
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	public int getLeggs() {
		return leggs;
	}
	public void setLeggs(int leggs) {
		this.leggs = leggs;
	}
	public void eat() {
		System.out.println(leggs+"条腿的"+color+"的"+name+"在吃饭");
	}
}

set和get方法

这里private里不能被访问，大大提高了安全性，但安全性之外，我们还是想要调用，怎么办，一是设置public类，但是这样就直接被访问了，不符合，所以就有了第二类方法set和get，从单词意思不难理解，set是设置，get是获取。因此，这两个方法是对数据进行设置和获取用的。set是赋值给设定的变量，return返回这个值给类。这两个方法可以在后面的子类中进行调用，调用的方法为a.set（…）。

四 、构造方法

构造方法 对象一建立就会调用构造方法，可以创建对象，给成员变量（属性）初始化。

1、方法名和类名相同
2、没有返回值和void，没有return
3、不能被static等关键字修饰
4、可以方法重载（定义多个参数列表不同的构造方法）
5、当一个类中没有写构造方法时，系统会默认给该类一个默认的无参构造方法。当自己定义构造方法后默认的构造方法就不存在了。（自己定义有参的构造方法后，如果还想使用无参的构造方法，就要自己再添加一个无参的构造方法）

1、无参构造

当一个类中没有写构造方法时，系统会默认给该类一个默认的无参构造方法。当自己定义构造方法后默认的构造方法就不存在了。（自己定义有参的构造方法后，如果还想使用无参的构造方法，就要自己再添加一个无参的构造方法）

public class Animal {
    String name;
    int age;
 //无参数构造方法，没有参数
    public Animal(){
        System.out.println("------无参的构造方法------");
        name = "动物";
        age = 0;
    }
 测试：
     public static void main(String[] args) {
        //创建对象
        Animal a1 = new Animal();
        System.out.println(a1.name+","+a1.age);
    }
}

2、有参构造

对象一建立就会调用构造方法，可以创建对象，给成员变量（属性）初始化。

public class Animal {
    String name;
    int age;
 //有参构造方法传参设置初始值
 public Animal(String name,int age){
        System.out.println("------有参的构造方法------");
        this.name = name;
        this.age = age;
    }
     public static void main(String[] args) {
        //创建对象实例化,有参构造方法创建对象是就把参数设计好
        Animal a2 = new Animal("兔子",2);
        System.out.println(a2.name+","+a2.age);
    }
}

五 、成员变量与局部变量

（成员变量） 定义在方法的外部，类的内部。
使用范围是整个类 不需要初始值 存储在堆内存中（对象存在时才在存在）

局部变量 （方法中的变量）

定义在方法的内部或者某一个语句块的内部，适用范围仅限于方法内或者语句块内 必须有初始值 存储在栈内存中

六 、包装类

包装类就是：将基本数据类型包装成对象，使其具有了对象的属性和方法

我们一般将“基本数据类型转换成包装类”的过程叫做装箱，将“包装类转换成基本数据类型”的过程叫做拆箱。
在这里插入图片描述
二、包装类的一些特性：
所有包装类都可以将与之对应的基本数据类型作为参数来创建它们的实例对象

· 除了Character类之外，其他包装类都可以将一个字符串作为参数来构造它们的实例

· Boolean类的构造方法参数为String类型时，若该字符串为true（不论大小写），则该对象表示true，否则表示false

· 当包装类Number构造方法的参数为String类型时，字符串不能为null，并且该字符串必须能够解析为基本类型的数据

三、用途
集合不允许存放基本数据类型

四、常见考点

1、包装类中“==”与equals的用法比较

值得注意的是，包装类中的equals方法和String类一样，都是重写了Object类中的equals方法，因此比较的是内容而不是地址，而“”比较的依然是引用变量的地址，只是当包装类型和与之相对应的基本类型进行“”比较时会先做自动拆箱处理。

2、包装类缓存

部分包装类提供了对象的缓存，实现方式是在类初始化时提前创建好会频繁使用的包装类对象，当需要使用某个包装类的对象时，如果该对象包装的值在缓存的范围内，就返回缓存的对象，否则就创建新的对象并返回。

3、常见笔试或面试问题举例

1 System.out.println(Integer.valueOf("1000")==Integer.valueOf("1000"));   --false
2 System.out.println(Integer.valueOf("128")==Integer.valueOf("128"));    --false
3 System.out.println(Integer.valueOf("127")==Integer.valueOf("127"));   --true
4 System.out.println(Integer.valueOf("-128")==Integer.valueOf("-128"));   --true   
5 System.out.println(Integer.valueOf("-1000")==Integer.valueOf("-1000"));    --false

1、自动拆箱与自动装箱

自动装箱、拆箱（Autoboxing and Unboxing）
自动装箱：Java 编译器会自动将基本类型转换为包装类（调用 valueOf 方法）
自动拆箱：Java 编译器会自动将包装类转换为基本类型（调用 xxxValue 方法）

自动装箱
就是可以把一个基本类型变量赋给对应的包装类变量或者Object变量


Integer i1 = 10;   ---> 等价于 Integer i1 = Integer.valueOf(10);

Object num = 10;   ---> 自动装箱 等价于: Object num1 = Integer.valueOf(10);

public static void main(String[] args) {
	    add(20);   --->  等价于 add(Integer.valueOf(20)); 
}
static void add(Integer num) {       
 }

自动拆箱
就是把一个 包装类 或者 Object变量 赋给对应的基本数据类型可。

Integer i1 = 10;

int i2 = i1; 
 --->  等价于: int i2 = i1.intValue();

System.out.println(i1 == 10);
 ---> 等价于: System.out.println(i1.intValue() == 10);


 包装类数组:
Integer[] array = { 11, 22, 33, 44 }; // 包装类数组
	int result = 0;
	for (Integer i : array) {
	    // i.intValue() % 2 == 0
		if (i % 2 == 0) { // 自动拆箱
			// result += i.intValue();
			result += i; //自动拆箱
		}
	}

七 、代码块

在java中用 { } 括起来的称为代码块，代码块可分为以下四种：

一.简介
1.普通代码块：
类中方法的方法体

2.构造代码块：
构造块会在创建对象时被调用，每次创建时都会被调用，优先于类构造函数执行。

3.静态代码块：
用static{}包裹起来的代码片段，只会执行一次。静态代码块优先于构造块执行。

4.同步代码块：
使用synchronized（）{}包裹起来的代码块，在多线程环境下，对共享数据的读写操作是需要互斥进行的，否则会导致数 据的不一致性。同步代码块需要写在方法中。

二.静态代码块和构造代码块的异同点
相同点：都是JVM加载类后且在构造函数执行之前执行，在类中可定义多个，一般在代码块中对一些static变量进行赋值。

不同点：静态代码块在非静态代码块之前执行。静态代码块只在第一次new时执行一次，之后不在执行。而非静态代码块每new一次就执行一次。

1、 普通代码块

普通代码块是我们用得最多的也是最普遍的，它就是在方法名后面用{}括起来的代码段。普通代码块是不能够单独存在的，它必须要紧跟在方法名后面。同时也必须要使用方法名调用它。

public class Test {
    public void test(){
        System.out.println("这是普通代码块");
    }
}

2、静态代码块

想到静态我们就会想到static，静态代码块就是用static修饰的用{}括起来的代码段，它的主要目的就是对静态属性进行初始化。

public class Test {
//静态代码块
    static{
        System.out.println("这是静态代码块");
    }
}

3、构造代码块

四、 构造代码块
在类中直接定义没有任何修饰符、前缀、后缀的代码块即为构造代码块。我们明白一个类必须至少有一个构造函数，构造函数在生成对象时被调用。构造代码块和构造函数一样同样是在生成一个对象时被调用，那么构造代码在什么时候被调用？如何调用的呢？看如下代码：

public class Test {
    构造代码块    
    {
        System.out.println("执行构造代码块...");
    }
    
    无参·构造函数 
    public Test(){
        System.out.println("执行无参构造函数...");
    }
        
     有参·构造函数 
    public Test(String id){
        System.out.println("执行有参构造函数...");
    }

执行顺序：
静态代码块 > 构造代码块 > 构造函数

public class Test {
 
      无参构造函数 
    public Test(){
        System.out.println("执行构造代码块...");
        System.out.println("执行无参构造函数...");
    }
    
     有参构造函数
    public Test(String id){
        System.out.println("执行构造代码块...");
        System.out.println("执行有参构造函数...");
    }
 
}
 运行结果：
 
public static void main(String[] args) {
        new Test();
        System.out.println("----------------");
        new Test("1");
    }
------------
Output:
执行构造代码块...
执行无参构造函数...
----------------
执行构造代码块...
执行有参构造函数...

八 、匿名对象

匿名对象的特点
创建匿名对象可以直接使用，没有变量名

  new Person().work();     //work 方法被一个没有名字的

Person 对象调用了 匿名对象在没有指定其引用变量时，只能使用一次

  new Person().work();    //创建一个匿名对象，调用 work 方法
  new Person().work();     //想再次调用 work方法，要重新创建一个匿名对象 匿名对象可以作为方法接收的参数，方法返回值使用

主要用在某个方法中的参数为一个对象时，不用事先new一个对象取一个对象名，可以直接在调用方法时new对象，而不用写对象名

public class Person {
    public String name; // 姓名
    public int age; // 年龄
    // 定义构造方法，为属性初始化
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // 可调用方法
    public void tell() {
        System.out.println("姓名：" + name + "，年龄：" + age);
    }
    public static void main(String[] args) {
 // 匿名对象，调用方法
        new Person("张三", 30).tell(); 
    }
}

九 、内部类

Java 一个类中可以嵌套另外一个类，称为内部类
要访问内部类，可以通过创建外部类的对象，然后创建内部类的对象来实现。

嵌套类有两种类型：

   非静态内部类 
   静态内部类


class OuterClass {   // 外部类
    // ...
    class NestedClass { // 嵌套类，或称为内部类
        // ...
    }
}

1、非静态内部类

非静态内部类是一个类中嵌套着另外一个类。 它有访问外部类成员的权限， 通常被称为内部类。

由于内部类嵌套在外部类中，因此必须首先实例化外部类，然后创建内部类的对象来实现。


class OuterClass {
  int x = 10;

  class InnerClass {
    int y = 5;
  }
}

public class MyMainClass {
  public static void main(String[] args) {
//创建外部类对象
    OuterClass myOuter = new OuterClass();
//创建内部类对象
    OuterClass.InnerClass myInner = myOuter.new InnerClass();
    System.out.println(myInner.y + myOuter.x);
  }
}

2、静态内部类

静态内部类可以使用 static 关键字定义，静态内部类我们不需要创建外部类来访问，可以直接访问它： 注意：静态内部类无法访问外部类的成员。

实例
class OuterClass {
  int x = 10;

  static class InnerClass {
    int y = 5;
  }
}

public class MyMainClass {
  public static void main(String[] args) {
//创建内部类直接访问
    OuterClass.InnerClass myInner = new OuterClass.InnerClass();
    System.out.println(myInner.y);
  }
}

3、从内部类访问外部类成员

内部类一个高级的用法就是可以访问外部类的属性和方法：

class OuterClass {
  int x = 10;

  class InnerClass {
    public int myInnerMethod() {
      return x;
    }
  }
}

public class MyMainClass {
  public static void main(String[] args) {
//创建外部类对象
    OuterClass myOuter = new OuterClass();
// 创建内部类对象
    OuterClass.InnerClass myInner = myOuter.new InnerClass();
//访问内部类的方法
    System.out.println(myInner.myInnerMethod());
  }
}

十 、继承

类的继承格式 在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的，一般形式如下：

类的继承格式

  class 父类 {
  	 }   
  class 子类 extends 父类 {
     }

限制：
1、一个子类只能够继承一个父类，存在单继承局限。
2：在一个子类继承的时候，实际上会继承父类之中的所有操作（属性、方法），但是需要注意的是，对于所有的非私有（no private）操作属于显式继承（可以直接利用对象操作），而所有的私有操（private）作属于隐式继承（间接完成）。
3，在继承关系之中，如果要实例化子类对象，会默认先调用父类构造，为父类之中的属性初始化，之后再调用子类构造，为子类之中的属性初始化，即：默认情况下，子类会找到父类之中的无参构造方法。
在任何的情况下，子类都逃不出父类构造的调用，很明显，super调用父类构造，这个语法和this()很相似：super调用父类构造时，一定要放在构造方法的首行上。

方法重写

父类的成员方法只能被它的子类重写。
参数列表与被重写方法的参数列表必须完全相同。

声明为 final 的方法不能被重写。

声明为 static 的方法不能被重写，但是能够被再次声明。

子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。

子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。

构造方法不能被重写。
重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

在面向对象原则里，重写意味着可以重写任何现有方法

父类：
class Animal{
   public void move(){
      System.out.println("动物可以移动");
   }
}
子类继承父类： 
class Dog extends Animal{
   public void move(){
      System.out.println("狗可以跑和走");
   }
}
 
public class TestDog{
   public static void main(String args[]){
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象
 
      a.move();// 执行 Animal 类的方法
 
      b.move();//执行 Dog 类的方法
   }
}

方法重载：

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。
最常用的地方就是构造器的重载。

重载规则:

被重载的方法必须改变参数列表(参数个数，类型，顺序不一样)； 被重载的方法可以改变返回类型； 被重载的方法可以改变访问修饰符；
被重载的方法可以声明新的或更广的检查异常； 方法能够在同一个类中或者在一个子类中被重载。 无法以返回值类型作为重载函数的区分标准。 实例

public class Overloading {
    public int test(){
        System.out.println("test1");
        return 1;
    }
 
    public void test(int a){
        System.out.println("test2");
    }   
 
    //方法重载，参数类型顺序不同
    public String test(int a,String s){
        System.out.println("test3");
        return "returntest3";
    }   
 
    public String test(String s,int a){
        System.out.println("test4");
        return "returntest4";
    }   
 
    public static void main(String[] args){
        Overloading o = new Overloading();
        System.out.println(o.test());
        o.test(1);
        System.out.println(o.test(1,"test3"));
        System.out.println(o.test("test4",1));
    }
}

在这里插入图片描述

Object

Java Object 类 Java Object 类是所有类的父类，也就是说 Java 的所有类都继承Object，
子类可以使用 Object 的所有方法。
使用Object类型可以接收所有类的对象
在这里插入图片描述

浅拷贝

1、直接赋值

直接赋值是我们最常用的方式，它只是拷贝了对象引用地址而已，并没有在内存中生成新的对象在我们代码中的体现是

  Person  a = new  Person();
  Person  b = a

public static void main(String[] args) {
       // 初始化一个对象
       Person person = new Person("张三",20,"123456@qq.com","我是张三");
       // 复制对象
       Person person1 = person;
       // 改变 person1 的属性值
       person1.setName("我不是张三了");

在这里插入图片描述

需要被复制类需要实现 Cloneable 接口，重写 clone 方法即可，对 person 类进行改造，使其可以支持浅拷贝。clone
也非常简单只需要调用 object 的 clone 方法就好，唯一需要注意的地方就是 clone 方法需要用 public 来修饰

 Person person = new Person("平头",20,"123456@qq.com","技术");
        // 复制对象
        Person person1 = (Person) person.clone();
        // 改变 person1 的属性值
        person1.setName("我是平头的克隆对象");

深克隆

深拷贝也是对象克隆的一种方式，相对于浅拷贝，深拷贝是一种完全拷贝，无论是值类型还是引用类型都会完完全全的拷贝一份，在内存中生成一个新的对象，简单点说就是拷贝对象和被拷贝对象没有任何关系，互不影响。
在这里插入图片描述

多态？？？

多态的实现的必要条件:
1.存在继承关系
2.存在方法重写
3.父类引用指向子类对象 向上转型（自动转换） 格式：<父类型> <引用变量名> = new <子类型>();
特点： 子类转为父类 父类的引用指向子类对象。可以理解为自动进行类型转换(和自动类型转换完全是两个概念) 此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法
此时通过父类引用变量无法调用子类特有的属性和方法

向下转型（强制转换） 格式：<子类型> <引用变量名> = (<子类型> )<父类型的引用变量>; 特点：
父类转为子类，父类引用转为子类对象。可以理解为强制类型转换

抽象方法

抽象方法特点：

只有方法的头没有方法体
抽象方法用abstract来修饰
抽象方法代表一种不确定的操作或行为
抽象方法不能被调用

  public abstract void work();

抽象类

抽象类的特点

定义中含有抽象方法的类叫抽象类
抽象类用abstract来修饰
抽象类代表一种抽象的对象类型 抽象类不能实例化
抽象类中可以有具体方法，可以有抽象方法

   public abstract class A{ 	
  		public void methodA() {
   	} 	
  	    public abstract void methodB(); }

接口

接口用关键字interface修饰

  public interface 接口名 {}

类实现接口用implements表示

  public class 类名 implements 接口名 {}

接口使用的步骤：
接口不能直接使用，（不能直接new接口）必须有一个“实现类”来“实现”该接口
（1）这个“实现类”和子类差不多，但是由有所不同

   子类格式：public class 子类名称 extends 父类{}
   实现类格式：public class 实现类名称 implements 接口名称{}

（2）接口的实现类必须重写接口中的所有抽象方法，（就是去掉abstracrt关键字，加上方法体 { }）

例如，鸟都有fly()和eat()两个行为，可以定义一个接口，如下：

interface Bird {
    public abstract void fly();
    public abstract void eat();
}

1 接口不能实例化
2、java单继承，不支持多继承 ，java支持多实现，一个类可以同时实现多个接口，重写所有抽象方法后才不用做抽象类
3，继承类A与实现接口B 中有相同的带方法体的方法，优先执行类A的方法

抽象方法

在接口中定义抽象方法的时候
抽象方法的一般格式

  public abstract 返回值类型 方法名（）;

(1)但是在接口中抽象方法，修饰符必须是两个固定的关键字 public abstract
(2)其中public abstract 可以省略
(3)方法的三要素可以随意更改,如下：

public interface Myinterface {
以下都可以
	public abstract void method();
	public void method1();
	abstract void method2();
	void method3();
}

接口static

1.从Java 8开始，接口当中允许定义静态方法。 格式：

  public static 返回值类型 方法名称（参数列表）{
      方法体
  }

提示：就是将abstract或者default换成static即可，带上方法体。

2.接口静态方法的使用：
注意事项:不能通过接口实现类的对象来调用接口当中的静态方法.

正确用法:通过接口名称 点 直接调用其中的静态方法.

格式:

接口名称 . 静态方法名(参数);

接口中定义一个静态方法：

public interface MyStatic { 
    public static void methosStatic(){
        System.out.println("这是一个接口的静态方法!");
    }
}

实现类：


public class MyStatic01 implements MyStatic{
//没有抽象方法 不需要覆盖重写
}

:通过接口名称 点 直接调用其中的静态方法.

public class DemoInterfaceStatic {
    public static void main(String[] args) {
//通过接口名称 点 直接调用其中的静态方法. 
        MyInterfaceStatic.methosStatic();
    }
}

接口default

default修饰方法只能在接口中使用，在接口种被default标记的方法为普通方法，可以直接写方法体。
接口提供一个默认实现的方法，并且不强制实现类重写此方法 默认方法使用default关键字来修饰

如果接口中有default方法：

public interface demo {
	public default void demoFun(){
		System.out.println("我是接口");
	}
}

Test类实现接口：

public class Test implements demo {
	
}

那么Test类将会继承接口demo 中的demoFun方法：

public class Test2 {
	public static void main(String[] args) {
		Test t = new Test();
		t.default();
	}
}

2.如果一个类同时实现接口A和B

接口A和B中有相同的default方法，这时，该类必须重写接口中的default方法
(因为，类在继承接口中的default方法时，不知道应该继承哪一个接口中的default方法。)

接口A：

public interface A {
	public default void c(){
		System.out.println("方法A");
	}
}

接口B：

public interface B {
	public default void c(){
		System.out.println("方法B");
	}
}

text类：
相同的default方法，这时，该类必须重写接口中的default方法

public class Test implements A,B {
	@overried
	public default void c(){
		System.out.println("方法A,B");
	}
}

函数式接口

函数式接口概念：
函数式接口：有且只有一个抽象方法的接口，称之为函数式接口
当然接口中可以包含其他的方法（默认，静态，私有）
函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。
只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。

格式
只要确保接口中有且仅有一个抽象方法即可：

  修饰符 interface 接口名称 { 
   	public abstract 返回值类型  方法名称(可选参数信息);
  	 // 其他非抽象方法内容 }

@FunctionalInterface注解
与 @Override 注解的作用类似，Java 8中专门为函数式接口引入了一个新的注解：
@FunctionalInterface 。该注解可用于一个接口的定义上：

/*
    函数式接口：有且只有一个抽象方法的接口，称之为函数式接口
    当然接口中可以包含其他的方法（默认，静态，私有）

    @FunctionalInterface注解
    作用：可以检测接口是否是一个函数式接口
        是：编译成功
        否：编译失败（接口中没有抽象方法抽象方法的个数多余1）
*/
@FunctionalInterface
public interface function {
    //定义一个抽象方法
    public abstract void method();
}

/*
    @Override注解
    检查方法是否为重写的方法
        是：编译成功
        否：编译失败
*/
public class function01 implements function{   
    @Override
    public void method() {
    }
}

lamda表达式

Lambda表达式格式：(参数) -> {对象.方法名(参数)}

lambda 表达式，又称匿名函数，Lambda表达式使用依赖于接口，并对接口有要求。Lambda
规定接口中只能有一个需要被实现的方法（即只能有一个抽象方法），不是规定接口中只能有一个方法，这也称之为“函数式接口

Lambda 表达式的简单例子:

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

无参无返回值

/**无参无返回值*/

@FunctionalInterface
public interface NoReturnNoParam {
    void method();
}
//--------------------------------------------
public class Test1 {
    public static void main(String[] args) {
 
        //无参无返回
        NoReturnNoParam noReturnNoParam = () -> {
            System.out.println("NoReturnNoParam");
        };
        noReturnNoParam.method();

一个参数无返回

/**一个参数无返回*/
@FunctionalInterface
public interface NoReturnOneParam {
    void method(int a);
}
//--------------------------------------------
public class Test1 {
    public static void main(String[] args) { 
 //一个参数无返回
        NoReturnOneParam noReturnOneParam = (int a) -> {
           System.out.println("NoReturnOneParam param:" + a);
        };
        noReturnOneParam.method(6);

多参数无返回

/**多参数无返回*/
@FunctionalInterface
public interface NoReturnMultiParam {
    void method(int a, int b);
}
//--------------------------------------------
public class Test1 {
    public static void main(String[] args) {
 //多个参数无返回
   NoReturnMultiParam noReturnMultiParam = (int a, int b) -> {
      System.out.println("NoReturnMultiParam param:" + "{" + a +"," + + b +"}");
        };
   noReturnMultiParam.method(6, 8);

无参有返回值

/** 无参有返回*/
@FunctionalInterface
public interface ReturnNoParam {
    int method();
}
//--------------------------------------------
public class Test1 {
    public static void main(String[] args) {
//无参有返回值
        ReturnNoParam returnNoParam = () -> {
            System.out.print("ReturnNoParam");
            return 1;
        };
        int res = returnNoParam.method();
        System.out.println("return:" + res);

/**一个参数有返回值*/
@FunctionalInterface
public interface ReturnOneParam {
    int method(int a);
}
//--------------------------------------------
public class Test1 {
    public static void main(String[] args) {
  //一个参数有返回值
        ReturnOneParam returnOneParam = (int a) -> {
            System.out.println("ReturnOneParam param:" + a);
            return 1;
        };
          int res2 = returnOneParam.method(6);
        System.out.println("return:" + res2);

/**多个参数有返回值*/
@FunctionalInterface
public interface ReturnMultiParam {
    int method(int a, int b);
}
//--------------------------------------------
public class Test1 {
    public static void main(String[] args) {
   //多个参数有返回值
        ReturnMultiParam returnMultiParam = (int a, int b) -> {
            System.out.println("ReturnMultiParam param:" + "{" + a + "," + b +"}");
            return 1;
        };
        int res3 = returnMultiParam.method(6, 8);
        System.out.println("return:" + res3);
    }

方法引用

方法引用格式： 对象::方法名

方法引用符
双冒号::为引用运算符，而它所在的表达式被称为方法引用。如果Lambda要表达的函数方案已经存在于某个方法的实现中，那么则可以通过双冒号来引用该方法作为Lambda的替代者。

枚举

Java 枚举是一个特殊的类，一般表示一组常量，比如一年的 4 个季节，一个年的 12 个月份，一个星期的 7 天，方向有东南西北等。

Java 枚举类使用 enum 关键字来定义，各个常量使用逗号 , 来分割

public enum SexEnum {
    male,female;
}
public enum Color {
    RED,BLUE,GREEN,BLACK;
}
xhj～
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值