static、静态导入、成员变量的初始化、单例模式、final 常量（Content）、嵌套类、局部类、抽象类、接口、Lambda、方法引用

7 阅读 0 评论 0 点赞

static

static 常用来修饰类的成员：成员变量、方法、嵌套类

成员变量

被static修饰：类变量、成员变量、静态字段
- 在程序中只占用一段固定的内存（存储在方法区），所有对象共享
- 可以通过实例、类访问 (一般用类名访问和修改，不建议用实例修改)，但是不能通过类名访问实例变量和实例方法
没有被static修饰:实例变量
- 每个实例都有一份内存

package com.hxw.demo4;

public class Person {
    public static  int count = 0;
    public int age;
}

package com.hxw.demo4;
public class Main {
    public static void main(String[] args) {
        Person.count = 20;

        Person p1 = new Person();
        p1.age = 20;

        System.out.println(p1.count);

        Person p2 = new Person();
        p2.age = 30;
        System.out.println(p2.count);
        
    }
}

控制台输出

20
20

方法

被static修饰：类方法、静态方法
- 可以通过实例、类访问
- 内部不可以使用this
- 可以直接访问类变量、类方法
- 不可以直接访问实例变量和实例方法
没有被static修饰：实例方法
- 只能通过实例访问，不可以通过类访问
- 内部可以使用this
- 可以直接访问实例变量和实例方法

package com.hxw.demo4;

public class Person {
    public static int count = 0;
    public int age;

    // 实例方法
    public void run1(){
        // 实例方法中可以使用this调用其他实例方法
        this.run2();
        //实例方法可以直接访问类变量和类方法
        System.out.println(count);
        test1();
        System.out.println(this.age);
    }

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

    public static void test1(){
        System.out.println("static void test1");
        test2();
        System.out.println(count);
    }
    public static void test2(){
        System.out.println("static void test2");
    }
}

package com.hxw.demo4;

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.age = 18;
        person.run1();

        Person.test1();
    }
}

总结：
在这里插入图片描述

静态导入

使用了静态导入之后，就可以省略类名来访问静态成员（成员变量、方法、嵌套类）

在这里插入图片描述

静态导入的经典应用

为了避免每一次都是用Math.PI,可以考虑使用静态导入，其他的Math方法也是一样的道理。
在这里插入图片描述

成员变量的初始化

编译器会自动为未初始化的成员变量设置初始值
如何手动给实例变量提供初始值
- 在声明中：定义变量的时候直接给其设置初始值
- 在构造方法中：在构造方法内部利用this进行初始化
- 在初始化中：这个情况看下面代码，了解一下,

package com.hxw.dmeo6;

public class Person {
    public static int count;
    public int age = 1; //申明中
    public Person(){
        age = 20;// 在构造方法中，但是先执行初始化中的代码
    }

    //在初始化中
    {
        age = 18;
    }
}

一般很少使用初始化代码,方法如下公共初始化代码一般放到参数最多的构造方法中

package com.hxw.dmeo6;

public class Person {
    public static int count;
    public int age = 1; //申明中

    public Person(){
        this(0, 0);
    }
    public Person(int age){
        this(age, 0);
    }
    public Person(int age, int no){
        // 公共初始化代码一般放到参数最多的构造方法中
    }

//    //在初始化中
//    {
//        age = 18;
//    }
}

如何手动给类变量提供初始值
- 在声明中
- 在静态初始化代码块中：当一个类初始化的时候（也就是一个类第一次被主动使用时，JVM会对类进行初始化），就会执行静态初始化代码块，且只会执行一次。
  - 可以有多个静态初始化块，按照在源码中出现的顺序被执行

在这里插入图片描述

初始化块和静态初始化块

这里实际的执行顺序和自己想的不一样，要先初始化完父类，再初始化子类
在这里插入图片描述

单例模式

如果一个类设计为单例模式，那么程序运行过程，这个类只能创建一个实例

饿汉单例模式：一开始就创建了对象
懒汉单例模式：等到该创建对象的时候创建对象，懒汉单例模式会有线程安全问题如果三个对象同时构建实例，那么会创建多个对象，但是最终创建的才会赋值给instance，所以总的说来还是单例模式

Rocket.class

package com.hxw.demo7;

/**
 * 饿汉式单例模式：一上来就new了一个对象
 */
//public class Rocket {
//    //私有的静态(唯一内存)实例变量
//    private static Rocket instance = new Rocket();
//
//    // 构造方法私有化 在Main中就不能new Rocket()
//    private Rocket(){
//
//    }
//
//    //公共的静态方法，返回唯一的静态实例
//    public static Rocket getInstance(){
//        return instance;
//    }
//}

/**
 * 懒汉式单例模式
 */

public class Rocket {
    public static Rocket instace = null;
    private Rocket(){

    }
    public static Rocket getInstance(){
        //用到的时候再new对象
        if(instace == null){
            instace = new Rocket();
        }
        return instace;
    }
}

Main.class

package com.hxw.demo7;

public class Main {
    public static void main(String[] args) {
        Rocket r1 = Rocket.getInstance();
        Rocket r2 = Rocket.getInstance();
        Rocket r3 = Rocket.getInstance();

        //r1 r2 r3 都是同一个instance

        System.out.println(r1 == r2);

        System.out.println(r2 == r3);
    }
}

控制台输出

true
true

final和常量

被final修饰的类不能被继承
被final修饰的成员方法不能被重写
被final修饰的变量，只能进行一次赋值，而且需要初始化，如果定义的时候没有初始化，那么在构造函数中一定要初始化

在这里插入图片描述

常量（Content）

常量的写法： public static final double PI = 3.14159265358979323846;,一般名字全部用大写
如果将基本类型或字符串定义为常量，并且在编译时就能确定值，编译器就会使用常量值代替各处的常量名（类似于C语言的宏替换），这样可以减少访问内存的次数，提高代码运行的效率

嵌套类

内部类（Inner Class，非静态嵌套类）

嵌套类：定义在另一个类中的类
外部类：在嵌套类外层的类
顶级类：最外层的外部类
内部类：没有被static修饰的嵌套类，非静态嵌套类。
- 跟实例变量、实例方法一样，内部类与外部类的实例相关联**，必须先创建外部类实例，然后再用外部类实例创建内部类实例**。
- 内部类不能定义除了除编译时常量以外的任何static成员
- 内部类可以直接访问外部类中的所有成员（即使被申明为static）因为先创建了外部类实例，再创建内部类实例。
- 外部类可以直接访问内部类实例的成员变量、方法
  外部类、内部类如下

package com.hxw.demo9;

public class OuterClass {
    // 静态嵌套类
    static class StaticNestedClass {

    }

    // 非静态嵌套类（内部类）
    class InnerClass{

    }
	
	class A{
        class B{
          class C{
              
          }
        }
    }

}

在这里插入图片描述
对应的内存图如下

静态嵌套类

静态嵌套类：被static修饰的嵌套类
静态嵌套类在行为上就是一个顶级类，只是定义的代码写在了另一个类中
对比一般的顶级类，静态嵌套类多了一些特殊权限
- 可以访问外部类中的成员（即使被申明为static）

在这里插入图片描述

什么情况使用嵌套类

情况一：如果类A只用在类C内部，可以考虑将类A嵌套到类C内部

封装性更好
程序包更加简化
增强可读性、维护性

情况二：如果类A需要经常访问类C的非公共成员，可以考虑将类A嵌套到类C中

另外也可以根据需要将类A隐藏起来，不对外暴露

情况三：如果需要经常访问非公共的实例成员（而且需要现有外层，后有内层的关系，例如现有公司Company 后有员工Employee），设计成内部类（非静态嵌套类），否则设计成静态嵌套类
- 如果必须现有C实例，才能创建A实例，那么可以将A设计为C的内部类

情况一案例：
在这里插入图片描述

局部类

局部类：定义在代码块（包含{}，可以在里面写代码的块）中的类（可以定义在方法中，for循环中，if语句中）
局部类不能定除编译时常量以外的任何static成员
局部类只能访问final或者有效final（只赋值一次，没有被第二次赋值）的局部变量
局部类可以直接访问外部类的所有成员
- 局部类只有定义在实例相关的代码块中，才能直接访问外部类中的实例成员（实例变量、实例方法）

由于局部类是定义在代码块中的，所以其作用域也只局限于代码块中，因此，什么时候会用到局部类呢？当一个类是在一个代码块中使用的时候

package com.hxw.demo10;

public class Person {
    static {
        class A{

        }
    }
    {
        int age = 10;
        class A{
            
        }
    }
    public void test(){
        for (int i = 0; i < 10; i++) {
            class A{

            }
        }

        if(true){
            class A{

            }
        }else{
            class A{

            }
        }

        {
            class A{

            }
        }
    }
}

在这里插入图片描述

抽象类

抽象方法（Abstract Method）

抽象方法：被abstract修饰的方法
- 只有方法申明，没有方法实现
- 不能是private权限（因为定义抽象方法的目的就是为了让子类去实现）
- 只能是实例方法，而不能是类方法
- 只能定义在抽象类，接口中

package com.hxw.demo11;

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

    }
    public abstract void test();
}

抽象类

抽象类：被abstract修饰的类
- 可以定义抽象方法
- 不能实例化，但是可以自定义构造方法
- 子类必须实现抽象父类中的所有抽象方法（除非子类也是一个抽象类）
- 可以向非抽象类一样定义成员变量、常量、嵌套类型、初始化块、非抽象方法等，也就是，抽象类也可以完全不定义抽象方法

常见使用场景

抽取子类的公共实现到抽象父类中，要求子类必须要单独实现的去定义成抽象方法

接口（Interface）

联想到日常笔记本电脑的接口，不同厂商的USB长得都是一样的，这是他们遵守相同的标准

API（Application Programming Interface）
- 应用编程接口，提供给开发者调用的一组功能（无需提供源码）
java中的接口
- 一系列方法申明的集合
- 用来定义规范、标准

抽象类（abstract）是通过子类继承来实现其抽象方法，接口（Interface）是通过其他类实现该接口来实现其抽象方法

家教案例引入接口概念

有一个小孩，需要应聘家教，应聘要求：

会教授编程
会教踢足球
涉及的人群可能有：在校的学生，在校的老师、出租车司机

首先看没有使用接口：

定义一个孩子类

package com.hxw.demo12;

public class Child {
    private String name;

    private Student jiajiao;
    public Child(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Student getJiajiao() {
        return jiajiao;
    }

    public void setJiajiao(Student jiajiao) {
        this.jiajiao = jiajiao;
    }

    public void study(){
        jiajiao.jiaoBianCheng(this);
        jiajiao.jiaoZuQiu(this);
    }

}

定义一个学生类

package com.hxw.demo12;

public class Student {
    public void jiaoBianCheng(Child child){
        System.out.println("Student教" + child.getName() + "编程");

    }

    public void jiaoZuQiu(Child child){
        System.out.println("Student教" + child.getName() + "足球");
    }


}

主函数

package com.hxw.demo12;

public class Main {
    public static void main(String[] args) {
        Child child = new Child("Jack");
        child.setJiajiao(new Student());
        child.study();
    }
}

如果希望老师教学生的话，按照这种方式就需要再创建一个Teacher类…如果教课的人身份众多，就会创建多个类，要单独修改Child类中的jiajiao属性，以及本类中的方法，这样很繁琐，但是这些类本质上都是实现了两个方法，招人的要求是满足这两个要求，但是对于这个人其他的特征，其实不用了解。此时，就可以将这两个行为定义到接口当中，各种身份的家教去实现这个接口即可。

创建JiaJiaoable接口，将原来Student中的方法复制过去，并改写为抽象方法。

package com.hxw.demo12;

public interface JiaJiaoable {
    public abstract void jiaoBianCheng(Child child);

    public abstract void jiaoZuQiu(Child child);
}

Student类、Teacher类分别实现JiaJiaoable接口中的方法

package com.hxw.demo12;

public class Student implements JiaJiaoable{
    @Override
    public void jiaoBianCheng(Child child) {
        System.out.println("Student教" + child.getName() + "biancheng");
    }

    @Override
    public void jiaoZuQiu(Child child) {
        System.out.println("Student教" + child.getName() + "zuqiu");

    }
}

package com.hxw.demo12;

public class Teacher implements JiaJiaoable{

    @Override
    public void jiaoBianCheng(Child child) {
        System.out.println("Teacher教" + child.getName() + "biancheng");

    }

    @Override
    public void jiaoZuQiu(Child child) {
        System.out.println("Teacher教" + child.getName() + "zuqiu");
    }
}

修改孩子类的家教属性为借口类型

package com.hxw.demo12;

public class Child {
    private String name;

    private JiaJiaoable jiajiao;
    public Child(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public JiaJiaoable getJiajiao() {
        return jiajiao;
    }

    public void setJiajiao(JiaJiaoable jiajiao) {
        this.jiajiao = jiajiao;
    }

    public void study(){
        jiajiao.jiaoBianCheng(this);
        jiajiao.jiaoZuQiu(this);
    }

}

调用Main方法：

package com.hxw.demo12;

public class Main {
    public static void main(String[] args) {
        Child child = new Child("Jack");
        child.setJiajiao(new Student());
        child.study();

        child.setJiajiao(new Teacher());
        child.study();
    }
}

控制台输出

Student教Jackbiancheng
Student教Jackzuqiu
Teacher教Jackbiancheng
Teacher教Jackzuqiu

接口中可以定义的内容

可以定义：抽象方法、常量、嵌套类型，从java8开始定义
- 上述可以定义的内容都是隐式public的，因此可以省略public关键字
- 从java9开始可以定义private方法
常量可以省略static、final
- 接口中没有成员变量，写出来就是常量
抽象方法可以省略abstract
不能自定义构造方法、不能定义初始化块、不能实例化

Lambda

Lambda只能访问finial或者有效finial的局部变量
Lambda没有引入新的作用域

定义一个OuterClass

package com.hxw.demo13;

public class OuterClass {
    private int age = 1;

    public class InnerClass{
        private int age = 2;
        void inner(){
            Testable t = v -> {
                System.out.println(v);
                System.out.println(age);
                System.out.println(this.age);
                System.out.println(InnerClass.this.age);
                System.out.println(OuterClass.this.age);
            };
            t.test(3);
        }
    }

    public static void main(String[] args) {
        new OuterClass().new InnerClass().inner();
    }
}

方法引用

本站资源均来自互联网，仅供研究学习，禁止违法使用和商用，产生法律纠纷本站概不负责！如果侵犯了您的权益请与我们联系！

转载请注明出处：免费源码网-免费的源码资源网站 » static、静态导入、成员变量的初始化、单例模式、final 常量（Content）、嵌套类、局部类、抽象类、接口、Lambda、方法引用

点赞(0) 打赏

本文分类：文章资讯
本文标签：static、静态导入、成员变量的初始化、单例模式、final 常量（Content）、嵌套类、局部类、抽象类、接口、Lambda、方法引用
浏览次数：7 次浏览
本文链接：https://freeymw.com/article/34071.html

上一篇 > 百度搜索推广和信息流推广的区别，分别适用于什么场景！
下一篇 > 智能听诊器：宠物医疗行业的新动力

评论列表共有 0 条评论

暂无评论

static、 静态导入、成员变量的初始化、单例模式、final 常量（Content）、嵌套类、局部类、抽象类、接口、Lambda、方法引用

static

静态导入

静态导入的经典应用

成员变量的初始化

初始化块和静态初始化块

单例模式

final和常量

常量（Content）

嵌套类

内部类（Inner Class，非静态嵌套类）

静态嵌套类

什么情况使用嵌套类

局部类

抽象类

抽象方法（Abstract Method）

抽象类

接口（Interface）

家教案例引入接口概念

接口中可以定义的内容

Lambda

方法引用

评论列表 共有 0 条评论

发表评论 取消回复

static、静态导入、成员变量的初始化、单例模式、final 常量（Content）、嵌套类、局部类、抽象类、接口、Lambda、方法引用

评论列表共有 0 条评论

发表评论取消回复