代码块、单例模式、抽象、接口、匿名内部类、可变参数

最新推荐文章于 2023-10-11 20:06:21 发布

笑Smell

最新推荐文章于 2023-10-11 20:06:21 发布

阅读量118

点赞数

分类专栏： Java个人学习笔记文章标签： eclipse java 开发语言

本文链接：https://blog.csdn.net/ljj66666/article/details/121675712

版权

Java个人学习笔记专栏收录该内容

11 篇文章 1 订阅

订阅专栏

package demo211201;

代码块

public class TestK {
    // 变量
    // 方法
    // 代码块/代码片段/代码域/匿名方法
    {// 实例代码块-每次实例化对象时，在调用构造方法前，自动执行一次
        System.out.println("实例代码块");
    }
    static {// 静态代码块-仅在该类被第一次使用时自动执行一次
        System.out.println("静态代码块");
    }

    public TestK() {
        System.out.println(900);
    }

    public static void main(String[] args) {
        System.out.println(800);
        TestK k1 = new TestK();
        TestK k2 = new TestK();
        TestK k3 = new TestK();
    }
}

package demo211202;

import org.junit.Test;

//执行过程
//static修饰的成员在第一次使用该类时会被加载到内存中
//静态部分：类被第一次使用时，先加载静态成员变量的定义，再按照书写的顺序由上到下执行
//如静态代码块内的代码和静态成员变量定义时的初始化赋值过程。
//实例部分：对象每次实例化时，先加载实例成员变量的定义，再按照书写的顺序由上到下执行
//如实例代码块内的代码和实例成员变量定义是的初始化赋值过程

public class TestA {

    static {
        a = 11;
//        System.out.println(a+"+++");
    }
    static int a = 31;
    // 静态过程： int a;--->a=11;----->a=31;
    {
        b = 12;// 变量的赋值
//        System.out.println(b+"***");//使用
    }
    int b = 32;// 变量的定义
    // 实例过程： int b;--->b=12;----->b=32;
    
    @Test
    static void test() {
        System.out.println("55555");
    }

    public static void main(String[] args) {
        System.out.println(a + "---");
        System.out.println(new TestA().b + "===");
    }
}

package demo211202;

单例模式

public class TestC {
// 应用
// 设计模式-单例模式-保证类在内存中只有一个对象

  public static void main(String[] args) {
        F f0 = F.getInstance1();
        F f = F.f3;
    }
}

class F {
//    public static F F0 = new F();

    private F() {
    }

    // 比较：空间与时间的问题
    // 空间可由硬件部分优化，但是时间优化很难（更推荐使用饿汉式）

//饿汉式（静态变量）---直接创建出来类的对象（空间换取时间）
    // 类被使用的时候加载并初始化f1对象
    // 所以可能导致没有用过，造成没必要的空间浪费
    private static F f1 = new F();

    public static F getInstance1() {
        return f1;
    }

    // final---简化用法，可操作性低---饿汉式的简化
    public final static F f3 = new F();

//懒汉式--在需要的时候创建
    // 每次只有调用方法时才会创建对象，但只适合在单线程情况下使用（时间换取空间）
    // 多线程不推荐
    private static F f2 = new F();

    public static F getInstance2() {
        if (f2 == null) {
            f2 = new F();
        }
        return f2;
    }

//懒汉式的优化
    private static volatile F f4 = null;

    public static F getInstance4() {
        if (f4 == null) {
            synchronized (F.class) {
                f4 = new F();
            }
        }
        return f4;
    }

}

//单例--优缺点
//优点
//单例类只有一个实例，节省内存资源，对于一些需要频繁创建对象
//使用单例可以提高系统发性能
//可以在系统设置全局的数据，优化和共享数据
//缺点
//一般没有开放其他api，扩展出了修改代码，基本没有别的办法。

package demo211202;

抽象

public class TestD {
   // 抽象类
   // 所有的对象都是通过类进行描述的
   // 反过来说，并不是所有的类都是用来描述对象的

// 如果一个类中没有包含足够的信息来描述一个具体的对象
// 这样的类就是抽象类

   // 普通类
   // 抽象-abstract-功能修饰符-抽象的
   // 主要修饰：类+成员方法
   // 用途
   // 1-主要用来继承
   // 2-在其中定义公共的成员

 public static void main(String[] args) {
        TestD td0 = new TestD();
//        TestD1 td1=new TestD1();
        // 抽象类不能直接new调用构造方法进行实例化
//        TestD5 t5 = new TestD5();
        // 抽象类的构造方法意义：在子类实例化时，间接被执行调用
    }

   // abstract语法规则
   // 1-修饰位置=类、方法
   // 2-使用规则=继承、重写
   // 继承/抽象
   // 构造类的构造方法（可以存在，也可以不存在，只能被子类重写执行）

}

 abstract class TestD5 extends TestD4 {

     //抽相类重写
//    @Override
//    void test() {
//        // TODO Auto-generated method stub
//        
//    }

// 普通子类中必须对抽象父类中的抽象方法进行重新实现进行重写，或将子类变成抽象类
}

abstract class TestD4 {// 抽象类

    abstract void test();// 抽象方法-没有方法体的方法/没有被实现的方法
    // 抽象类不一定有抽象方法
    // 有抽象方法一定是抽象类

    public TestD4() {
        System.out.println("D4");
    }

    int a1;
    static int a2;

    void f1() {

    }

    static void f2() {

    }
}

abstract class TestD1 {// 抽象类

}

class TestD3 extends TestD1 {

}

package demo211202;

接口

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class TestE {

   // 接口
   // 官方：接口是一系列方法的声明，是一些方法特征的集合
   // 接口中只有方法的特征，没有方法的实现--抽象方法
   // 因此这些方法可以在不同的地方被不同的实现
   // 而这些实现可以具有不同的行为功能

   // 目的
   // 接口是解决Java中无法实现多继承的一种手段
   // 在实际开发应用中更多的是制定标准或规范方法的

    public static void main(String[] args) {
        // 面向接口的编程
        List<String> list1 = new ArrayList<>();
        //list---接口
        List<String> list2 = new LinkedList<>();
    }

    public static void test(String[] list) {
//        TestE1 t1 =new TestE1();
        TestE1 t2 = new TestE2();
    }

}

//接口和抽象类之间的语法区别
//1-构造方法：接口中不能有，抽象类中可以有（）
//2-方法体：接口中不能有（1.8可以有static/default），抽象类可以有
//3-代码块：接口中不能有，抽象类可以有
//4-变量：接口中默认是static public final，抽象列中没有默认（可自定义）

//类/接口/继承/实现
//（单）继承=类+和类
//（多）实现：类+接口
//（多）继承=接口+接口//一个类继承一个接口，实现多个接口

class TestE7 extends TestE5 implements TestE3, TestE4 {

}

interface TestE3 {

}

interface TestE4 {

}

//（多）继承
interface TestE6 extends TestE3, TestE4 {// 多继承

}

class TestE5 implements TestE3, TestE4 {

}

//（单）继承
class TestE2 implements TestE1 {// implements实现关系
    @Override
    public void f1() {

    }
}

//接口不是类，很相似而已
//类主要是用来描述对象的属性和方法
//接口主要是用来定义方法特征的

interface TestE1 {// TestE1--->接口名  //interface接口
    // 主要内容=抽象方法+共有静态的常量

    int a1 = 10;// 默认具有static public final的性质
    static int a2 = 10;

    void f1();// 抽象方法

    // TestE1(){}//接口中不可以有构造方法
    // void f1();// 不可以有实例方法
    // {}不可以有代码块
    // static{}

    static void f3() {// 静态方法
        System.out.println();
    }

    default void f4() {// 默认方法

    }
}

ackage demo211202;

匿名内部类

public class TestF {

   // 面向对象-三大特征
   // 封装=数据+操作
   // 继承=包含（可使用）上级
   // 多态=对象类型或方法实现的不同表现形式
   // --对象=向下+向下转型
   // --方法=重写+重载

   // 引用方法+引用传递
   // 访问修饰符-4
   // 功能修饰符-final/static
   // this/super

   // Object
   // toString equals.
   // instanceof

// extends implements
// abstract interface

   public static void main(String[] args) {
       // 匿名内部类=去使用这个没名字的类实例化出一个对象
       // 语法格式规则
       // new AAA(){}
       // AAA=上级文件名()
       // 匿名内部类必须继承一个父类或实现一个接口（只能有一个）

}

package demo211202;

可变参数

import java.util.Arrays;
import java.util.List;

public class TestG {

   // 可变参数/不定参数
   // 适用于参数个数不确定+确定类型的情况
   //
   // 特点：
   // 1-不定参数在参数列表中只能出现在最后
   // 2-...位于变量名称和变量类型之间，前后有无空格都可
   // 3-调用可变参数的方法时候，编译器未改可变参数隐含创建一个数组。

 public static void f0(String s1, String... s2) {
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s2.length);
        System.out.println(Arrays.toString(s2));//遍历--输出全部元素
    }

    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
//        f0();
//        f0("aaa");
        f0("aaa", "bbb", "ccc");

    }
}