程序员经验分享-hwhale

Java基础（2）面向对象的理解

2023-10-27

面向对象学习

面向对象与面向过程的区别

面向过程思想适合简单、不需要协作的任务，

面向对象需要很多协作才能完成，面向对象就应运而生了。

object（对象），instance（实例）

  1. 都是解决问题的思维模式，都是代码组织的方式

  2. 解决简单问题可以使用面向过程

  3. 解决复杂问题：宏观上使用面向对象把握，微观处理上仍然是面向过程。

对象是什么，对象和数据管理

事物的发展总是遵循“量变引起质变”的哲学原则，起初是并不需要对象的，

  1. 数据无管理时代：不做任何管理

  2. 数据管理和企业部门制：因此有了数组的概念

  3. 对象和企业项目制：项目组合一个独立的公司差不多，例如腾讯微信组

对象是包含了不同类型的数据

对象和类的关系、属性、成员变量、方法

对象和类的概念

类（class）可以看做是对象的模板

抽象是抽出像的部分形成一个类，某个类的对象，某个类的实例是一样的意思。

类中包括属性（成员变量）和方法，

只有属性没有方法，只能叫做结构体。

一个典型类的定义和类的UML图

看到new " " 就代表创建一个对象

构造方法，用于创建这个类的对象，无参的构造方法可以由系统自动创建

UML图直观的表示一个类的结构。

内存分析

Java虚拟机的内存可以分为三个区域，栈（stack），堆(heap)、方法区（method area），方法区也在堆中

栈

  1. 栈描述的是方法执行的内存模型，每个方法被调用都会创建一个栈帧（存储局部变量、操作数、方法出口等)
  2. JVM为每个线程创建一个栈，用于存放该线程执行方法的信息（实际参数、局部变量等）
  3. 栈属于线程私有，不能实现线程间的共享！
  4. 栈的存储特性是“先进后出，后进先出”
  5. 栈是由系统自由分配，速度快！栈是一个连续的内存空间。

堆

  1. 堆用于存储创建好的对象和数组（数组也是对象）
  2. JVM 只有一个堆，被所有线程共享
  3. 堆是一个不连续的空间，分配灵活，速度慢

方法区

  1. JVM只有一个方法区，被所有线程共享。
  2. 方法区实际也是堆，只是用于存储类、常量相关的信息！
  3. 用来存放程序中永远是不变或唯一的内容。（类信息，class对象、静态变量、字符串常量等）

构造方法

构造器也叫构造方法，用于对象的初始化

构造方法的第一句总是super，即使不书写，编译器也会自动添加

要点：

  1. 通过new关键字调用
  2. 构造器虽然有返回值，但是不能定义返回值类型（返回值的类型肯定是本类），不能在构造器里面使用return返回某个值
  3. 如果我们没有定义构造器，则编译器会自动定义一个无参的构造函数，如果已定义则编译器不会自动添加！
  4. 构造器的方法名必须和类名一致。

return作用：1. 结束方法运行，

  1. 返回值。

垃圾回收机制

  1. 发现无用的对象。

  2. 回收无用对象占用的空间。

垃圾回收相关算法

  1. 引用计数法：缺点是循坏引用的无用对象 ，无法被识别
  2. 引用可达法（根搜索算法）：较为常用。

通用的分代垃圾回收机制

年轻代、年老代、持久代

等学到一定程度 ——回看067 开发中容易造成内存泄漏的操作。

this关键字

对象创建的过程

  1. 分配对象空间，并将对象成员变量初始化为0或为空

  2. 执行属性值的显示初始化

  3. 执行构造方法

  4. 返回对象的地址给相关的变量

this的本质

就是创建好的对象的地址，由于在构造方法调用前，对象已经创建，因此，在构造方法中也可以使用this代表当前对象。

构造器的调用只能位于第一列

this不能用于static方法中 ，this指的是当前对象

static关键字

static ‘静态’的意思，用static声明的成员变量为静态成员变量，也称为类变量，类变量的生命周期和类相同，在整个应用程序执行期间都有效

static修饰的成员变量和方法，从属于类

普通变量和方法从属于对象

静态方法无法使用非静态的方法。

静态方法可以使用静态变量

把普通与静态看做汽车和汽车的设计图纸作比加深理解。普通方法可以调用静态方法，好比有汽车必有图纸。

静态初始化块（讲完继承回头再看一遍）

静态初始化块用于类的初始化。

继承树的追溯

参数传值机制

Java中所有参数传值都是值传递，也就是传递的值的副本，传递的是地址的拷贝

public class test {
    public static void main(String[] args) {
        User4 u1=new User4(100,"高小七");
        u1.testParameterTransfer01(u1);
        System.out.println(u1.name);
    }
    public static class User4
    {
        int id;
        String name;
        String pwd;

    public User4(int id,String name){
        this.id = id;
        this.name=name;
    }

    public  void testParameterTransfer01(User4 u){
            u.name="高小八";
        }
    }
}

Java包机制

包机制是Java中管理类的重要手段。开发中，我们会遇到大量同名的类，通过包我们很容易对解决类重名的问题，也可以实现对类的有效管理，包对于类，相当于文件夹对于文件的作用。

包名位于第一句，一定是非注释性的语句。

import详解

静态导入

加*代表导入所有类。

面向对象三大特征

继承

继承（extends),子类是父类的拓展，

Java中只有单继承，Java的接口可以多继承

子类继承父类，可以得到父类的全部属性和方法（除了父类的构造方法），但不见得可以直接访问，比如，父类私有的属性和方法。

方法的重写override

子类通过重写父类的方法，可以用自身的行为替换父类的行为

方法重写的要点：

  1. ==：方法名，形参列表相同
  2. “<=”:返回值类型和声明异常类型，子类小于等于父类
  3. “>=”：访问权限，子类大于父类

object类的用法

object类时所有Java类的根基类，也就意味着所有的Java对象都拥有object类的属性和方法。

super关键字

super是直接父类对象的引用，可以通过super来访问父类中被子类覆盖的方法或属性

构造方法的调用顺序

  1. 构造方法的第一句总是super（），是默认的。，所以，流程是：先向上追溯带object。然后在依次向下执行类的初始化和构造方法，知道当前子类为止。
  2. 静态初始化块的调用顺序，与构造方法调用顺序一样。

封装的作用和含义

程序设计追求的是“高内聚，低耦合”，高内聚就是内部数据操作自己完成，不允许外部干涉，低耦合是仅暴露少量的方法给外部使用，尽量方便外部调用

封装的优点：

  1. 提高代码的安全性
  2. 提高代码的复用性
  3. 高内聚：粉转细节，便于内部修改代码，提高可维护性
  4. 低耦合：简化外部调用，便于调用者使用，便于拓展和协作

封装的实现—使用访问控制符

  1. private表示私有，只有自己类能访问
  2. default表示没有修饰符修饰，只有同一个包的类能访问
  3. protected表示可以被同一个包的类以及其他包中的子类能访问
  4. public表示可以被该项目的所有包中的所有类访问

（子类不可以引用父类的私有属性和方法）

封装的使用细节

类的属性的处理：

  1. 一般使用private访问的权限
  2. 提供相应的get/set方法来访问相关属性，这些方法通常是public修饰的，以提供对属性的赋值与读取操作（注意：Boolean变量的get方法是is开头的）
  3. 一些只用与本类的辅助性方法可以用private修饰，希望其他类所使用的方法用public修饰。

多态

多态指的是同一个方法的调用，由于对象不同可能会有不同的行为，现实生活中，同一个方法，具体实现会完全不同。

多态的要点

  1. 多态是方法的多态，不是属性的多态（多态与属性无关）
  2. 多态的存在要有3个必要条件：继承，方法重写，父类引用指向子类对象
  3. 父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了

对象的转型

自动向上转型：子类可以自动转型为父类

强制向下转型，可以将父类的对象转为子类（自上而下）

UNStudent st2=(UNStudent) st1;

强制转型转化后父类可以调用子类中特有的方法

子类的对象转为父类（自下而上）是自动转型。

final关键字

  1. 修饰变量：被修饰的变量不可改变，一旦赋了初值，就不能被重新赋值
  2. 修饰方法：该方法不可被子类重写，但是可以被重载
  3. 修饰类：修饰的类不可被继承，比如Math,String。

数组

数组是相同类型数据的有序集合，数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称做一个元素，每个元素可以通过一个索引（下标）来访问它们。

基本特点：

  1. 长度是确定的，数组一旦被创建，它的大小就是不可以改变的
  2. 其元素必须是相同类型，不允许出现混合类型
  3. 数组类型可以是任意数组类型，包括基本数据类型和引用类型
  4. 数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。

数组的初始化

数组的初始化方式总共有三种：静态初始化、动态初始化、默认初始化。

静态初始化

int[] a = {3, 4, 5};//静态初始化

默认初始化

int a2[]=new int[2];//默认初始化

动态初始化

int []a1=new int[2];
a1[0]=1;
a1[1]=2;//动态初始化

数组的遍历

public class test {
    public static void main(String[] args) {
        int []a =new int[4];
        for (int i= 0;i<a.length;i++){
            a[i]=100*i;
    }
        for (int i = 0;i<a.length;i++){
            System.out.println(a[i]);
        }
    }
}

for-each循环

专门用于读取数组或集合中所有的元素，即对数组进行遍历

for (int m :a){
    System.out.println(m);
}

数组的拷贝

public static void testBsaicCopy(){
        String [] s1 = {"aa","bb","cc","dd","ee"};
        System.arraycopy(s1,3,s1,3-1,s1.length-3);
        s1[s1.length-1] = null;
        for (int i = 0; i<s1.length;i++){
            System.out.println(i+""+s1[i]);
        }
    }

数组的扩容

//数组的扩容（本质上是：先定义一个更大的数组，然后将原数组内容拷贝到新数组中）
 public static void extendRange(String[]s1){
    //String[]s1={"aa","bb","cc"};
    String[]s2=new String[s1,0,s2,0,s1.length];
    for (String temp:s2){
        System.out.println(temp);
    }
    }

Arrays类

是一个工具类

public class TestArrays {
    public static void main(String[] args) {
        int[]a={100,20,35,5,50,80};
        System.out.println(a);
        //打印指定的数组内容
        System.out.println(Arrays.toString(a));
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        System.out.println(Arrays.binarySearch(a,35));

    }

}

多维数组

可以看成以数组为元素的数组

int[][] a=new int[3][];
        a[0]=new int[]{20,30};
        a[1]=new int[]{10,15,80};
        a[2]=new int[]{50,60};
        System.out.println(a[1][2]);

        //静态初始化二维数组
        int b [][]={
                {20,30,40},
                {50,20},
                {100,200,300,400}
        };
        System.out.println(b[2][3]);
    }

数组存储表格数据

Object[] emp1 = {1001, "李文泽", "学生", "2001-12-03"};
        Object[] emp2 = {1002, "李文泽", "学生", "2003-04-03"};
        Object[] emp3 = {1003, "李文泽", "学生", "2009-05-03"};
        Object[][] tableData = new Object[3][];
        tableData[0] = emp1;
        tableData[1] = emp2;
        tableData[2] = emp3;
        for (Object[]temp:tableData){
            System.out.println(Arrays.toString(temp));
        }

冒泡排序优化排序

算法如下:

  1. 比较相邻的元素，如果第一个比第二个大，就交换他们两个
  2. 对每一对相邻元素作相同的工作，从开始第一对到结尾的最后一对，在这一点，最后的元素应该会是最大的数
  3. 针对所有的元素重复以上的步骤，除了最后一个
  4. 持续每次对越来越少的元素重复上面的步骤，知道没有任何一对数字需要比较
基本算法
public class TestBubbleSort {
    public static void main(String[] args) {
        int[] values = {3, 1, 6, 2, 9, 0, 7, 4, 5, 8};
        int temp = 0;
        for (int i = 0; i < values.length - 1; i++) {
            for (int j = 0; j < values.length - 1-i; j++) {
                if (values[j] > values[j + 1]) {
                    temp = values[j];
                    values[j] = values[j + 1];
                    values[j + 1] = temp;
                }
                System.out.println(Arrays.toString(values));
            }
                System.out.println("***************");
        }
    }
}
优化算法
public class TestBubbleSort {
    public static void main(String[] args) {
        int[] values = {3, 1, 6, 2, 9, 0, 7, 4, 5, 8};
        int temp = 0;
        for (int i = 0; i < values.length - 1; i++) {
            boolean flag=true;
            for (int j = 0; j < values.length - 1-i; j++) {
                if (values[j] > values[j + 1]) {
                    temp = values[j];
                    values[j] = values[j + 1];
                    values[j + 1] = temp;
                    flag=false;
                }
                System.out.println(Arrays.toString(values));
            }
            if (flag){
                System.out.println("结束");
                break;
            }
                System.out.println("***************");
        }
    }
}

二分法查找（折半检索）

基本要求：数组要排好序

//测试二分法查找
public class TestBinarySearch {
    public static void main(String[] args) {
        int[] arr = {30, 20, 50, 10, 80, 9, 7, 12, 100, 40, 8};
        Arrays.sort(arr);
        int value = 10;

        System.out.println(Arrays.toString(arr));
        System.out.println(myBinarySearch(arr,40));
    }
public static int myBinarySearch(int []arr, int value){
    int low=0;
    int high=arr.length-1;
    while (low<=high){
        int mid=(low+high)/2;
        if (value==arr[mid]){
            return mid;
        }
        if (value>arr[mid]){
            low=mid+1;
        }
        if (value<arr[mid]){
            high=mid-1;
        }
    }


    return -1;
}
}

抽象类、抽象方法

抽象方法

使用abstract修饰的方法，没有方法体，只有声明，定义的是一种“规范”，就是告诉子类必须要给抽象方法听过具体的实现

抽象类

包含抽象方法的类就是抽象类，通过abstract方法定义规范，然后要求子类必须定义具体实现（必须重写），通过抽象类，我们就可以做到严格限制子类的设计，是子类之间更加通用

使用要点

  1. 有抽象方法的类只能定义成抽象类
  2. 抽象类不能实例化，即不能用new来实例化抽象类
  3. 抽象类可以包含属性、方法、构造方法，但是构造方法不能用来new实例，只能用来被子类调用
  4. 抽象类只能用来被继承
  5. 抽象方法必须被子类实现

抽象类的意义就在于：为子类提供统一的、规范的模板，子类必须实现相关的抽象方法。

接口

接口是比“抽象类”更抽象的“抽象类”，接口的本质是契约

定义接口的说明：

  1. 访问修饰符：只能是public或者默认default
  2. 接口名：和类名采取相同的命名机制
  3. extends:接口可以多继承
  4. 常量：接口中的属性只能是常量，总是：public static final 修饰，不写也是
  5. 方法：接口中的方法只能是：public abstract，省略的话，也是public abstract。

要点

  1. 子类通过implements来实现接口中的规范
  2. 接口不能创建实例，但是可用于声明变量了类型
  3. 一个类实现了接口，必须实现接口中所有的方法，并且这些方法只能是public的
  4. JDK1.7之前，接口中只能包含静态常量、抽象方法，不能有普通属性、普通方法、构造方法

内部类

成员内部类

成员内部类包含非静态内部类和静态内部类

非静态内部类

非静态内部类可以直接访问外部类的成员，但是外部类不能直接访问内部类的成员。

  1. 非静态内部类必须寄存在一个外部类对象里，因此，如果有一个非静态内部类对象，那么一定存在对应的外部类对象，非静态内部类对象单独属于外部类的某个对象
  2. 非静态内部类可以直接访问外部类成员，但是外部类不能直接访问非静态内部类成员
  3. 非静态内部类不能有静态方法，静态属性和静态代码块
  4. 外部类的静态方法、静态代码块不能访问非静态内部类，包括不能使用非静态内部类定义变量、创建实例
成员变量访问要点
  1. 内部类里方法的局部变量：变量名
  2. 内部类属性：this.变量名
  3. 外部类属性：外部类名.this.变量名。
静态内部类

用static修饰

使用要点
  1. 当一个静态内部类对象存在，并不一定存在对应的外部类对象。因此，静态内部类的实例方法不能直接访问外部类的实例方法
  2. 静态内部类看做外部类的一个静态成员，因此，外部类的方法可以通过：“静态内部类.名字”的方式访问静态内部类的静态成员，通过new 静态内部类（）访问静态内部类的实例。

匿名内部类

注意：

  1. 匿名内部类没有访问修饰符
  2. 匿名内部类没有构造方法，因为没有名字

局部内部类

方法内部定义的，作用域只限于本方法，成为局部内部类

string类

  1. string类称作不可变序列
  2. Java字符串就是Unicode字符序列
  3. 比较字符串使用equals（），不要使用==

StringBuilder(可变字符串序列)

String str;
        //StringBuilder线程不安全，效率高（一般使用它）；StringBuffer线程安全，效率低
        StringBuilder sb =new StringBuilder("abcdefg");
        System.out.println(Integer.toHexString(sb.hashCode() ));
        System.out.println(sb);
        sb.setCharAt(2,'M');
        System.out.println(Integer.toHexString(sb.hashCode()));
        System.out.println(sb );

StringBuilder sb =new StringBuilder();
        for (int i=0; i<26;i++){
            sb.append((char)('a'+i));
        }
        System.out.println(sb);
        sb.reverse();//倒序
        System.out.println(sb);
        sb.setCharAt(3,'高');
        System.out.println(sb);
        sb.insert(0,'我').insert(6,'爱').insert(10,'你');//链式调用。核心就是：该方法调用了return this，把自己返回了。
        System.out.println(sb);
        sb.delete(20,23);
        System.out.println(sb)

注意

/*使用String进行字符串的拼接*/
        String str ="";
        long num1=Runtime.getRuntime().freeMemory();//获取系统剩余内存空间
        long time1=System.currentTimeMillis();
        for (int i=0;i<500;i++){
            str = str+i;
        }
        long num2=Runtime.getRuntime().freeMemory();
        long time2=System.currentTimeMillis();
        System.out.println("String占用内存："+(num1-num2 ));//975256
        System.out.println("String占用时间："+(time2-time1));//17ms
        /*
        使用StringBuilder进行字符串的拼接
         */
        StringBuilder sb1=new StringBuilder("");
        long num3=Runtime.getRuntime().freeMemory();//获取系统剩余内存空间
        long time3=System.currentTimeMillis();
        for (int i=0;i<500;i++){
            sb1.append(i);
        }
        long num4=Runtime.getRuntime().freeMemory();
        long time4=System.currentTimeMillis();
        System.out.println("StringBuilder占用内存："+(num4-num3));//0
        System.out.println("StringBuilder占用时间："+(time4-time3));//0

建议使用stringbuilder进行循环拼接。

常量池

  1. 全局字符串常量池
  2. class文件常量池
  3. 运行时常量池

包装类

包装类位于Java.lang包

//Integer a = new Integer(3);
        //基本数据类型转化为包装类对象
        Integer a=new Integer(3);
        Integer b=Integer.valueOf(30);
        //把包装类对象转成基本数据类型
        int c =b.intValue();
        double d =b.doubleValue();
        //把字符串转成包装类对象
        Integer e = new Integer("9999");
        Integer f = new Integer("999888");
        //把包装类对象转化成字符串
        String str = f.toString();//""+f也可以
        //常见的常量
        System.out.println("int类型最大的整数"+Integer.MAX_VALUE);
        System.out.println("int类型最小的整数"+Integer.MIN_VALUE);

自动装箱和拆箱

自动装箱：基本类型的数据处于需要对象的环境中时，会自动转为“对象”

自动拆箱：每当需要一个值时，对象会自动转成基本数据类型，不需要再去显式调用intValue()、doubleValue()等转型方法

Integer a=234;//编译器会转化为 Integer a =Integer.valueOf(234)   自动装箱
        int b =a;  //编译器会修改成int b =a.intValue()  自动拆箱
        Integer c= null;
        if (c!=null){
            int d =c;   //自动拆箱，调用了：c.intValue
        }
        //缓存【-128,127】之间的数字,实际就是系统初始的时候，创建了【-128,127】之间的一个缓存数组
        //当我们调用valueOf（）的时候，首先检查是否在【-128,127】之间，如果在这个范围之间直接从缓存数组中拿出已经建好的对象
        //如果不在这个发范围，则创建新的Integer对象。
        Integer in1= -128;
        Integer in2= -128;
        System.out.println(in1==in2);//true，因为在缓存范围内
        System.out.println(in1.equals(in2));//true
        Integer in3=1234;
        Integer in4=1234;
        System.out.println(in3==in4);//false，因为1234不在缓存范围内
        System.out.println(in3.equals(in4));//true

DATE 时间类

1970年1月1日 00：00：00定为基准时间

Java中使用long类型的变量来表示时间，

 Date d =new Date(2000);
        System.out.println(d);

        System.out.println(d.getTime());

        Date d2 = new Date();
        System.out.println(d2.getTime());
        System.out.println(d2.after(d));
    //以后遇到日期处理，使用Canlendar日期类
        Date d3 = new Date(2020-1900,3,10);
       System.out.println(d3);//2020.4.10

DataFormat 类和 SimpleFormat 类

//把时间对象按照“格式字符串指定的形式”转成相应的字符串
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        String str = df.format(new Date(4000000));
        System.out.println(str);
        //把字符串按照“格式字符串指定的格式”转成相应的时间对象
        DateFormat df2 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        Date date = df.parse("1983-5-10 10:45:59");
        System.out.println(date);
        //测试其他的字符,利用D，或者获得本时间对象是所处年份的第几天
        DateFormat df3 = new SimpleDateFormat("D");
        String str3= df3.format(new Date());
        System.out.println(str3);

Calendar和GregorianCalendar的使用

Calendar calendar = new GregorianCalendar(2999,10,9,22,10,50);
        int year=calendar.get(Calendar.YEAR);
        int month=calendar.get(Calendar.MONTH);
        int weekday = calendar.get(Calendar.DAY_OF_WEEK);//星期几：1-7.1：星期日，2：星期一，7：星期六
        int day=calendar.get(Calendar.DATE);//也可以使用DAY_OF_MONTH.
        System.out.println(year);
        System.out.println(month);//0-11表示对应的月份，0是一月，依此类推。
        System.out.println(weekday);
        System.out.println(day);
        //设置日期相关的元素
        Calendar calendar1=new GregorianCalendar();
        calendar1.set(Calendar.YEAR,8012);
        System.out.println(calendar1);
        //日期的计算
        Calendar calendar2 =new GregorianCalendar();
        calendar2.add(Calendar.YEAR,-100);
        System.out.println(calendar2);
        //日期对象和时间对象的转化
        Date date = calendar2.getTime();
        Calendar calendar3 = new GregorianCalendar();
        calendar3.setTime(new Date());
        printCalendar(calendar3);
            }
    public static void printCalendar(Calendar c){
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH)+1;
        int date = c.get(Calendar.DAY_OF_MONTH);
        int dayWeek = c.get(Calendar.DAY_OF_WEEK)-1;
        String dayWeek1=dayWeek==0?"日":dayWeek+"";
        int hour =c.get(Calendar.HOUR);
        int minute=c.get(Calendar.MINUTE);
        int second=c.get(Calendar.SECOND);
        System.out.println(year+"年"+month+"月"+date+"日  "+hour+"时"+minute+"分"+second+"秒"+ "   周"+dayWeek);

File类

import java.util.Date;
import java.util.Objects;
import java.util.Properties;
import java.util.Scanner;

public class test {
    public static void main(String[] args) throws IOException {
        File f = new File("d:\\a.txt");
        File file =new File("d:/a.txt");
        file.createNewFile();
        System.out.println("File是否存在"+file.exists());
        System.out.println("File是否是目录"+file.isDirectory());
        System.out.println("File是否是文件"+file.isFile());
        System.out.println("File最后修改的时间"+new Date(file.lastModified()));
        System.out.println("File的大小"+file.length());
        System.out.println("File的文件名"+file.getName());
        System.out.println("File的目录路径"+file.getAbsoluteFile());
        //使用mkdirs和mkdir创建目录
        File file1 =new File("d:/电影/华语/大陆");
        boolean flag = file1.mkdirs();//目录结构中有一个不存在也没关系，创建整个目录树
        System.out.println(flag);
        //File类综合运用
        File file2 = new File("d:/sxt/b.txt");
        boolean flag1=file2.exists();
        if (flag1){
            boolean flagd = file2.delete();
            if (flagd){
                System.out.println("删除成功");
            }else {
                System.out.println("删除失败");
            }
        }else {
            boolean flagn=true;
            try {
                File dir = file2.getParentFile();
                dir.mkdirs();
                flagn = file2.createNewFile();
                System.out.println("创建成功");
            }catch (IOException e){
                System.out.println("创建失败");
                e.printStackTrace();
            }
        }

    }
}

枚举类

所有的枚举类型隐性地继承Java.lang.Enum.枚举实质上还是类，而每个被枚举的成员实质就是一个枚举类型的实例，默认都是public static final 修饰的，可以直接通过枚举类型名使用。

注意
  1. 当需要定义一组常量，可以使用枚举类型
  2. 尽量不要使用枚举的高级特性，事实上高级特性都可以使用普通类来实现，没有必要引入枚举，增加程序的复杂性。
ublic class test {
    public static void main(String[] args)  {
       System.out.println(Season.SPRING);
        Season a = Season.AUTUMN;
        switch (a){
            case SPRING:
                System.out.println("春天");
                break;
            case SUMMER:
                System.out.println("夏天");
                break;
            case AUTUMN:
                System.out.println("秋天");
                break;
            case WINTER:
                System.out.println("冬天");
                break;
        }
    }
}
enum Season{
    SPRING,SUMMER,AUTUMN,WINTER
}
enum Week{
    星期一,星期二,星期三,星期四,星期五,星期六,星期日,
}
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

Java小白的学习笔记

Java

Java基础（2）面向对象的理解 的相关文章

随机推荐

  • 【Qt】win10下安装Qt5.12.12

    文章目录 前言 一 下载安装包 二 安装步骤 1 注册账户 2 安装过程 前言 最近由于课题的需要 下载Qt 特此记录安装过程 一 下载安装包 笔者使用的是清华的源 也可以去官网下载 清华源如下 https mirror tuna tsin

  • 【华为OD机试】计算最接近的数【2023 B卷

    华为OD机试 真题 点这里 华为OD机试 真题考点分类 点这里 题目描述 给定一个数组X和正整数K 请找出使表达式 X i X i 1 X i K 1 结果最接近于数组中位数的下标 i 如果有多个 i 满足条件 请返回最大的 i 其中 数组

  • 图像掩膜的作用

    用选定的图像 图形或物体 对待处理的图像 全部或局部 进行遮挡 来控制图像处理的区域或处理过程 用于覆盖的特定图像或物体称为掩模或模板 光学图像处理中 掩模可以足胶片 滤光片等 数字图像处理中 掩模为二维矩阵数组 有时也用多值图像 数字图像

  • ROS机器人应用（4）—— 查看里程计、IMU 话题信息

    文章目录 1 查看ODOM IMU 话题信息 2 相关数据结构解释 1 查看ODOM IMU 话题信息 小车开机 连接WIFI 密码 dongguan SSH 远程登录 ssh wheeltec 192 168 0 100 密码 dongg

  • 关于知识图谱的应用方向

    如何利用大数据风控体系应对多渠道风险 1 合合信息失联客户管理知识图谱 部分借款人在借款成功后出现不还款现象并且 失联 使得催收人员因无法联系借款人本人 无从下手 借助知识图谱 挖掘出更多的与借款人有关系的新联系人 大大提高催收成功率 关联

  • guns+apiPost

    当通过guns接口生成器生成代码后 直接用已经生成的接口用于apiPost测试是不通过的 一种方式是处理这里的验证 另一种方式是为了便于接口测试 可以在shiroConfig设置该接口不验证 注意 不安全性也增加了 hashMap put

  • java判断文件类型

    页面代码

  • Python爬虫如何快速入门学习？

    Python爬虫是一种用于自动化网页数据抓取的技术 它能够帮助我们快速 高效地获取互联网上的数据 对于那些想要快速入门学习Python爬虫的人来说 可能会有一些困惑 如何才能快速掌握Python爬虫的基本原理和技巧 在本文中 我们将分享一些

  • Java线程同步-栅栏（CyclicBarrier）

    Java线程同步 栅栏 CyclicBarrier 栅栏是一种同步工具 用于等待一组线程达到某个共同点后再同时继续执行 它的内部维护一个计数器和一个屏障点 当线程到达屏障点时 会阻塞等待其他线程到达 每一个线程到达屏障点后 计算器就减1 当

  • 我在windows10下，使用msys64 mingw64终端

    系列文章目录 文章目录 系列文章目录 前言 一 MSYS2是什么 前言 msys2官网 MSYS2 Minimal SYStem 2 是一个MSYS的独立改写版本 主要用于 shell 命令行开发环境 同时它也是一个在Cygwin POSI

  • JavaDay06

    用户登录 提示用户输入用户名和密码 如果用户名和密码不是 admin 和 123 的话 就提示用户继续输入 最多输入五次 用户登录 提示用户输入用户名和密码 如果用户名和密码不是 admin 和 123 的话 就提示用户继续输入 最多输入五

  • 数据结构4-单链表的删除修改和查找

    1 单链表按照顺序插入节点 package com yin m3LinkedList public class SingleLinkedListDemo public static void main String args TODO Au

  • C语言（关于浮点数比较的学习）

    由于浮点数十进制转化成二进制的机制 会造成精度损失 因此在浮点数的比较中 无法直接令两个浮点数是否相等来判断两个浮点数 如 include

  • 上传报org.apache.tomcat.util.http.fileupload.impl.FileSizeLimitExceededException: The field file exceed

    错误如下 springBoot项目自带的tomcat对上传的文件大小有默认的限制 SpringBoot官方文档中展示 每个文件的配置最大为1Mb 单次请求的文件的总数不能大于10Mb 解决方法 Spring Boot 2 5 6 版本 在

  • 紫禁繁花服务器维护,各种坑的坑。

    该楼层疑似违规已被系统折叠 隐藏此楼查看此楼 最开始玩的小主 建议开菜坑 会拉开一部分势力 前期略微有明显 比如你冲宫斗去 冲榜去来它是首选 特别是国力的234榜 攻略摘要 势力增加快 复仇积分多 宫斗提升 雨露增加快 办差收货多 势力提升

  • C++使用dll的一些探索

    一 动态链接库的加载方式 隐式加载又称载入时加载 指在主程序载入内存时搜索DLL 并将DLL载入内存 使用隐式加载时 使用者需要DLL链接库的 h文件 lib文件和 dll文件 lib文件包含DLL导出的函数声明和变量的符号名 dll 文件

  • 旧电脑改造nas黑群晖_黑群晖教程：旧电脑不吃灰，手把手教你变成千元顶级NAS...

    前言 如果有玩PCDIY 玩摄影 玩PT 那么一定有听说过NAS NAS中群晖的NAS又是使用体验最佳的 群晖NAS系统在功能上十分齐全 人机界面做的也较为出众 但可惜的是 机器本体价格相对来说高昂 很多人在看到售价后只能摇摇头作罢 黑群晖

  • altium designer执行DRC检查+消除绿色错误

    由原理图生成PCB以后 各种显示绿色 也即PCB报错 如下图 绿色的原因是DRC Design Rule Check 检查未通过 解决方法是正确设置规则 但是在此之前 为了观感 我们先掩耳盗铃一下 临时清除绿色 步骤是 菜单栏 gt 工具

  • 线性代数-向量，矩阵，线性变换

    一 向量 向量要求具有两个条件 长度 大小 方向 二维 三维 计算机中 向量可看做列表 图中第一个列表有两行 我们说它是二维向量 第二个列表有四行 我们说他是四维向量 向量的运算 向量加法 向量加法 将对应的行相加 将向量w的起点平移到向量

  • Java基础（2）面向对象的理解

    面向对象学习 面向对象与面向过程的区别 面向过程思想适合简单 不需要协作的任务 面向对象需要很多协作才能完成 面向对象就应运而生了 object 对象 instance 实例 都是解决问题的思维模式 都是代码组织的方式 解决简单问题可以使用

热门标签