JAVASE8

最新推荐文章于 2023-04-04 10:04:57 发布

cnjss

最新推荐文章于 2023-04-04 10:04:57 发布

阅读量168

点赞数

分类专栏： java 后端文章标签： java

本文链接：https://blog.csdn.net/cnjss/article/details/115383931

版权

java 后端专栏收录该内容

20 篇文章 0 订阅

订阅专栏

JAVASE8

一、

接口：

使用interface关键字定义接口
定义标准,定义规范
接口需要通过implements实现

接口的优点：

是一个特殊的抽象类
是一个引用数据类型(类,接口,数组)
实现解耦耦合度
类只能单继承 ,接口多实现
更便于后期维护
定义开发规范
功能(抽象方法)的集合

注意:

父类需要被子类继承 ,接口需要被类实现 implements
继承: 子类一旦继承父类,就可以直接使用父类的成员
实现: 接口中一般都是大量的抽象方法,必须要被实现,重写方法才可以使用,实现一个接口,需要重写抽象
方法,侧重点在于实现
实现与继承非常像,实现也好,继承也好,都能够有权使用接口|父类中的成员|功能,但是侧重点不一样
接口中不能定义普通的方法,大部分为抽象方法
接口不能实例化

使用:

实现类实现接口,重写所有的抽象方法,通过实现类对象使用接口中的内容
抽象类或者接口的使用,最终都需要具体的子类|实现类,根据子类或者实现类的对象调用
一个类可以同时继承父类,并且实现多个接口,先继承后实现
类继承一个父类,类需要或只能实现接口
接口不能实现接口,接口只能继承接口,可以多继承

这里我们要清楚不同版本jdk的接口

jdk1.7版本及之前：

公共的静态的常量:
public static final 数据类型常量名 = 赋值;
修饰符可以任意省略 public static final
公共的抽象的方法
public abstract 返回值类型方法名(参数列表);
修饰符可以任意省略 public abstract

public interface InterfaceDemo01 {
    //公共的静态的常量:
    public static final double PI = 3.14;

    public abstract void haha();
    public abstract void hehe();
}

interface A{
    void a();
}

interface B{
    void b();
}

interface C{}

//接口可以多继承
interface D extends A,B,C{}


//接口的实现类
public class InterfaceImpl02 implements InterfaceDemo01{
    @Override
    public void haha() {
        System.out.println("哈哈哈笑");
    }

    @Override
    public void hehe() {
        System.out.println("呵呵呵笑");
    }

    //新增内容
    public void heihei() {
        System.out.println("嘿嘿嘿笑");
    }
}

//抽象实现类
abstract class InterfaceImpl03 implements InterfaceDemo01{
    @Override
    public void haha() {
        System.out.println("哈哈哈笑");
    }
    //public abstract void hehe();
}

//实现多个接口的案例
class Demo extends Object implements A,B,C{
    @Override
    public void a() {

    }

    @Override
    public void b() {

    }
}

class Demo2 implements D{
    @Override
    public void a() {

    }

    @Override
    public void b() {

    }
}

jdk1.8版本之后（了解即可）

1.静态方法
但是只能通过接口名使用,实现类对象不能使用
2.默认方法
通过实现类对象使用默认方法

public interface InterfaceDemo03 {
    //静态方法
    public static void testStatic(){
        System.out.println("接口中的静态方法");
    }

    //默认方法
    default void testDefault(){
        System.out.println("默认方法");
    }
}

//实现类
class Impl implements InterfaceDemo03{

}

二、

内部类：（了解即可）

类中定义类

当一个类中的成员,也是一个事物的时候,这个成员就可以定义为内部类（比如人与心脏）

分类:

成员内部类
局部内部类
私有内部类
静态内部类
匿名内部类 ***
Lambda表达式

成员内部类:

一个类作为另外一个类的成员
拥有成员与类的特性
成员内部类中不可以定义静态内容,除了静态常量
成员内部类中可以使用外部类中的所有成员,包括私有的
在外部类中通过内部类的对象使用内部类中的成员,包括私有的
其他类中使用成员内部类中的内容,需要通过外部类对象构建内部类对象,通过内部类对象使用内部类中的成员

//外部类
public class Outer01 {
    //成员
    private int i = 1;

    //成员内部类
    public class Inner{
        //成员变量
       private String name = "成员内部类的name";
        //静态的常量
        static final int X= 123;

        //成员方法
        public void innerMethod(){
            System.out.println("成员内部的成员方法");
            System.out.println(X);
            System.out.println(name);
            System.out.println(i);
        }
    }

    //外部类的方法
   public void outerMehtod(){
       System.out.println(Inner.X);
       //内部类对象
       Inner in = new Inner();
       System.out.println(in.name);
   }
}

私有内部类

使用private 关键字修饰成员内部类
在外部类中通过私有内部类的对象使用成员
在内部类中可以直接使用外部类中的成员,包含私有的
私有的内部类只能在当前的外部类中使用

public class Outer03 {

    //成员
    private int i  = 1;

    //私有内部类
    private class Inner{
        private String str = "私有内部类中的成员";

        void testInner(){
            System.out.println("私有内部类中的成员方法");
            System.out.println(str);
            System.out.println(i);
        }
    }

    void testOuter(){
        System.out.println("外部类的成员方法");
        //通过内部类的对象使用内部 类中的成员,包含私有的
        Inner in = new Inner();
        in.testInner();
        System.out.println(in.str);
    }
}

静态内部类

static关键字修饰的成员内部类

静态内部类中可以定义静态内容,其他成员成员内部类中不可以定义静态内容,除了静态的常量
静态内部类也是静态的内容,想要使用成员就需要通过对应类型的对象调用其成员
在其他类中使用静态内部类中的静态内容,通过外部类名.静态内部类名.静态内容
在其他类中使用静态内部类中的成员内容,通过new 外部类名.静态内部类名()的对象调用成员

public class Outer04 {
    //成员变量
    private int i = 1;
    //静态变量
    private static int j = 10;

    //静态内部类
    static class Inner{
        int a = 5;
        static int b = 15;

        //成员方法
        void test(){
            System.out.println("静态内部类中的成员方法");
            System.out.println(a);
            System.out.println(b);
            System.out.println(j);
            System.out.println(new Outer04().i);
        }

        //静态方法
        static void testStatic(){
            System.out.println("静态内部类中的静态方法");
            System.out.println(b);

            //在静态内部类中的静态方法中,需要通过内部类对象使用成员
            System.out.println(new Inner().a);
            //在静态内部类中的静态方法中,需要通过外部类对象使用成员
            System.out.println(new Outer04().i);
            System.out.println(j);
        }
    }

}

局部内部类（了解）

不能使用public,…static…修饰符修饰,final(太监类)可以
如果在局部内部类中使用当前中的局部变量,默认被final修饰(jdk8默认,jdk7及之前必须手动添加final)
局部内部类中的内容只有在当前方法中通过局部内部类的对象使用其成员

public class Outer05 {

    void test(int args){
        //局部
        int i = 1;
        //i = 1000;

        //局部内部类
        class Inner extends Object{
            public int a = 5;
            static final int b = 10;  //静态常量

            void test(){
                System.out.println("局部内部类中的成员方法");
                System.out.println(i);
                System.out.println(args);
            }
        }

        new Inner().test();
        System.out.println( new Inner().a);
    }
}

匿名内部类（重点）

简化实现类|子类的,因为接口或者抽象类中可能纯在抽象方法,必须在实现类|子类中重写,可以通过匿名内部类简化实现类|子类

创建一个匿名内部类的对象
new 接口名|抽象类名() {
匿名内部类的类体;
}
创建的就是当前这个接口的实现类|这个抽象类的子类的对象

public class Outer06 {
    public static void main(String[] args) {
        //创建一个Smoke实现类的对象
        //Demo  d = new Demo();

        //new 一个叫做Smoke接口的实现类的对象,这个实现类没有类名,所有是匿名的,但是{}就是实现类的类体
        //1) 匿名对象: 只能在当前行使用一次
        new Smoke(){

            @Override
            public void smoking() {
                System.out.println("边吸烟边敲代码...");
            }
        }.smoking();

        //匿名内部类的匿名对象,只能在当前行使用一次
        new AbsDemo(){

            @Override
            void test() {
                System.out.println("抽象类的匿名子类");
            }

            @Override
            void test2() {

            }
        }.haha();

        //2.当前作用域中使用多次匿名内部类对象,通过接口类型的引用指向
        //接口多态   接口类型的引用指向实现类对象
        Smoke s = new Smoke(){

            @Override
            public void smoking() {
                System.out.println("边吸烟边游泳!!!!");
            }
        };

        s.smoking();
        s.smoking();
        s.smoking();

        //3.匿名内部类对象作为方法的参数
        testSmoke(new Smoke() {
            @Override
            public void smoking() {
                System.out.println("吸烟的时候什么都能做哈哈哈哈");
            }
        });
    }
    //只能接受有抽烟能力的
    static void testSmoke(Smoke s){
        s.smoking();
    }
}

//接口
interface Smoke{
    void smoking();
}

//实现类
//demo实现类作用: 就是为重写抽象方法,但是这个类demo没有自己本身的作用
class Demo implements Smoke{

    @Override
    public void smoking() {
        System.out.println("边吸烟边吐烟圈...");
    }
}

//抽象类
abstract class AbsDemo{
    abstract void test();
    abstract void test2();

    public void haha(){
        System.out.println("hahahahah");
    }
}

三、

lambda表达式（重点）

目的: 为了简化匿名内部类对象
匿名内部类: 简化实现类|子类

lambda的前提:
函数式接口

函数式接口: 只有一个必须被重写的抽象方法的接口
检查函数式接口的方式: @FunctionalInterface

lambda表达式结构:
()->{}
(): 重写的抽象方法的参数列表
->: 箭头函数 lambda符号具有上下文推到的作用
{}: 重写的抽象方法的方法体

public class LambdaDemo01 {
    public static void main(String[] args) {
        //匿名内部类的对象
       /* Demo  demo = new Demo(){

            @Override
            public void test() {
                System.out.println("hahahaha");
            }
        };*/


        //lambda的接口简化匿名内部类对象的写法
        //写法1.lambda写法1
        /*Demo  demo =()->{
            System.out.println("哈哈哈笑");
        };*/

        //写法2.当抽象抽象方法的方法体语句只有一句的时候,前后的{}可以省略
        //Demo  demo =()->System.out.println("哈哈哈笑");

        //写法3.抽象方法有参数,参数的数据类型可以省略
        //Demo  demo =(a,b)->System.out.println("哈哈哈笑");

        //写法4.抽象方法的参数只有一个,前后的()可以省略
        //Demo  demo =a->System.out.println("哈哈哈笑");

        //写法5.抽象方法有返回值类型,方法的语句体只有一个,并且是return语句的时候,前后的{}与return关键字可以一起省略
        /*Demo demo = a ->{
            return "fanhuizhi";
        };*/

        Demo demo = a ->"fanhuizhi";

        System.out.println(demo.test(1));;
    }
}


//接口
@FunctionalInterface
interface Demo{
    String test(int a);
}

cnjss

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVASE8

JAVASE8一、接口：使用interface关键字定义接口定义标准,定义规范接口需要通过implements实现接口的优点：是一个特殊的抽象类是一个引用数据类型(类,接口,数组)实现解耦耦合度类只能单继承 ,接口多实现更便于后期维护定义开发规范功能(抽象方法)的集合注意:父类需要被子类继承 ,接口需要被类实现 implements继承: 子类一旦继承父类,就可以直接使用父类的成员实现: 接口中一般都是大量的抽象方法,必须要被实现,重写方法才可以使用
复制链接

扫一扫

专栏目录