Java周记2

m0_63513547

已于 2022-05-22 15:59:42 修改

阅读量353

点赞数

文章标签： java 开发语言

于 2022-05-22 15:58:46 首次发布

本文链接：https://blog.csdn.net/m0_63513547/article/details/124895935

版权

抽象类，抽象方法

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

抽象类的使用要点：

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

5.9.1接口

接口是比抽象类还“抽象”的抽象类。

声明格式：

interface 接口名 [extends交接口1，交接口2……]{

常量定义；

方法定义；

}

定义接口的详细说明：

访问修饰符：只能是public或默认。
接口名：和类名采用相同命名机制。
extends：接口可以多继承。
常量：接口中的属性只能是乘凉，总是：public static final 修饰。不写也是。
方法：接口中的方法只能是：public abstract 。省略的话，也是public abstract。

要点：

示例

package cn.sxt.oop;
/**
 * 测试接口和实现类
 * @author 15386
 *
 */
public class TestInterface {
	public static void main(String[] args) {
		Volant v=new Angle();
		v.fly();
		
		Honest h=new GoodMan();
		h.helpOther();
	}

}
/**
 *飞行窗口 
 * @author 15386
 *
 */
interface Volant{
	int FLY_HEIGHT=1000;
	void fly();
}

//善良接口
interface Honest{
	void helpOther();
}

class Angle implements Volant,Honest{//实现类可以实现多个父接口

	@Override
	public void helpOther() {
		System.out.println("Angel.helpOther()");	
	}

	@Override
	public void fly() {
		System.out.println("Angel.fly()");		
	}
		}
class GoodMan implements Honest{

	@Override
	public void helpOther() {
		System.out.println("GoodMan.helpOther()");
	}
}


class Birdman implements Volant{

	@Override
	public void fly() {
		System.out.println("Birdman.fly()");
		
	}
	
}

5.9.3 接口的多继承

接口可以多继承

package cn.sxt.oop;

public class TestInterface2 {

}

interface A{
	void testa();
}

interface B{
	void testb();
}

/*接口可以多继承；接口c继承接口A和B*/
interface C extends A,B{
	void testc();
}
class Test implements C{

	@Override
	public void testa() {			
	}

	@Override
	public void testb() {		
	}

	@Override
	public void testc() {		
	}
	
}

5.10.2内部类的分类

在Java中内部类主要分为成员内部类、非静态内部类、静态内部类、匿名内部类、局部内部类

成员内部类

a)非静态内部类

非静态内部类必须在一个外部类对象里
非静态内部类可以直接访问外部类的成员，但是外部类不能直接访问非静态内部类成员
非静态内部类不能有静态方法、静态属性和静态初始化块

外部类的静态方法、静态代码块不能访问非静态内部类，包括不能使用非静态内部类定义变量、创建实例

成员变量访问要点：

内部类里方法的局部变量：变量名
内部类属性：this.变量名
外部类属性：外部类名.this.变量名

b)静态内部类

静态内部类的实例方法不能直接访问外部类的实例方法
外部类的方法中可以通过：”静态内部类.名字“的方式访问静态内部类的静态成员，通过new静态内部类（）访问内部类的实例

c)匿名内部类

语法： new 父类构造器（实参类表）|实现接口（）{

}

5.11 String基础

String类又称不可变字符序列
String位于java.lang包下的所有类
Java字符串就是Unicode字符序列
Java没有内置的字符串类型，而是在标准Java类库中提供了一个预定义的类String
Java允许使用符号"+"把两个字符串连接起来

通常比较字符串使用equals。

5.11.1 String类常用方法

方法	解释说明
char charAt(int index)	返回字符串中第index个字符
boolean equals(String other)	如果字符串与other相等，返回true；否则，返回false
boolean equalsIgnoreCase(String other)	如果字符串与other相等，返回true；否则，返回false
int IndexOf(String str)	返回从末尾开始查找第一个字符串str在字符串里索引位置，如果未找到子字符串str，则返回-1
lastIndexOf()	返回从末尾开始查找第一个子字符串str在字符串中的索引位置，如果未找到子字符串str，则返回-1
int length()	返回字符串的长度
String replace(char oldChar,char newChar)	返回一个新串，它是通过用newChar替换此字符串中出现的所有oldChar而生成的
boolean startsWith(String prefix)	如果字符串以prefix结尾，则返回true
boolean endsWith(String prefix)	如果字符串以prefix结尾，则返回true
String substring(int beginIndex)	返回一个新字符串，该串包含从原始字符串begindex到串尾
String substring(int beginIndex,Int endIndex)	返回一个新的字符串，该字符串包含从原始字符串beginIndex到串尾或end

package cn.sxt.oop;

/**
 * 测试字符串的常用方法
 * @author 15386
 *
 */
public class TestString2 {
	
	public static void main(String[] args) {
		
		String s1="core java";
		String s2="Core java";
		System.out.println(s1.charAt(3));  //提取下标为3的字符
		
		System.out.println(s2.length());// 字符串长度
		
		
		System.out.println(s1.equals(s2));//比较两个字符串是否相等
		
		System.out.println(s1.equalsIgnoreCase(s2));//比较两个字符串（忽略大小）
		
		System.out.println(s1.indexOf("java"));//字符串s1中是否包含Java
		
		System.out.println(s1.indexOf("apple"));//字符串s1中是否包含apple
		String s=s1.replace(' ','&');//将字符串中的空格替换成&
		System.out.println("result is:"+s);
		
	}

}

package cn.sxt.oop;

/**
 * 测试字符串的常用方法
 * @author 15386
 *
 */
public class TestString2 {
	
	public static void main(String[] args) {
		
		String s="";
		String s1="How are you?";
		System.out.println(s1.startsWith("How"));//是否以How开头
		System.out.println(s1.endsWith("you")); //是否以you结尾
		
		s=s1.substring(4);//提取子字符串：从下标为4的开始到字符串结尾为止
		System.out.println(s);
		s=s1.substring(4,7);//提取子字符串：从下标为4的开始到下标为7结束，不包括7
		System.out.println(s);
			
		
		s=s1.toLowerCase();//转小写
		System.out.println(s);
		s=s1.toUpperCase();//转大写
		System.out.println(s);
		
	
		String s2="How old are you!";
		s=s2.trim();//去除字符串首尾的空格。注意：中间的空格不能去除
		System.out.println(s);
    }
}

7.3.3数组的拷贝

package cn.sxt.array2;

/**
 * 测试数组的拷贝
 * @author 15386
 *
 */
public class TestArrayCopy {
	public static void main(String[] args) {
		
		String[] str= {"阿里","京东","尚学堂","百度","亚马逊"};
		RemoveElment(str,1);
		
	}
		public static void testBasicCopy() {
		String[] s1 ={"aa","bb","cc","dd","ee"};
		String[] s2=new String[10];
		System.arraycopy(s1, 2,s2, 6, 3);
		
		for(int i=0;i<s2.length;i++) {
			System.out.println(i+"--"+s2[i]);
		}
		
	}

	
	
	//测试从数组中删除某个元素（本质上还是数组的拷贝）
	public static String[] RemoveElment(String[] s,int index) {
		System.arraycopy(s,index,s,index-1,s.length-index);
		
		s[s.length-1]=null;
		
		for(int i=0;i<s.length;i++) {
			System.out.println(i+"--"+s[i]);
		}
		return s;
		
	}
	
	//数组的扩容（本质上是定义一个更大的数组，然后将原数组内容原封不动拷贝到新数组中）
	public static void extendRange(String[] str) {
		String[] s1= {"aa","bb","cc"};
		
		String[] s2=new String[s1.length+10];
		
		System.arraycopy(s1, 0, s2, 0, s1.length);//就将s1中所有元素拷贝到了s2
	    
		for(String temp:s2) {
			System.out.println(temp);
		}
	}
}

arrays工具栏类的使用

import java.util.Arrays;
public class testarrays {
    public static void main(String[]args) {
        int[]a= {3,7,4,89,100,34,56};
        System.out.println(a);//输出地址
        System.out.println(Arrays.toString(a));//输出a内的元素
        Arrays.sort(a);//排序
        System.out.println(Arrays.toString(a));
        System.out.println(Arrays.binarySearch(a, 100));//返回索引
        System.out.println(Arrays.binarySearch(a, 50));//返回负数
        
    }
}

多维数组

public class testdimensionArray {
    public static void main(String[]args) {
        int[][]b=new int[3][];
        b[0]=new int[] {10,20};
        b[1]=new int[] {10,20,30};
        b[2]=new int[] {10,50,100,60};
        System.out.println(b[2][2]);//100
        //静态初始化二维数组
        int[][]c= {
                {20,30},
                {40,90,60},
                {100,455,54,245}
        };
        System.out.println(c[2][3]);//245
    }
}

多维数组存储表格数据

import java.util.Arrays;
 
public class testArrraytabledata {
    public static void main(String[]args) {
        Object[]emp1= {0001,"喜羊羊",8,"羊村","2000.1.1"};
        Object[]emp2= {0001,"灰太狼",10,"狼堡","2021.2.2"};
        Object[]emp3= {0001,"熊大",13,"狗熊岭","2008.8.4"};
        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. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较

import java.util.Arrays;
 
public class testbubblesort {
    public static void main(String[]args) {
        int[] value= {6,8,2,1,5,7,4,3};
        int temp=0;
        for(int i=0;i<value.length-1;i++) {
            boolean flag=true;
            
            for(int j=0;j<value.length-1-i;j++) {
                if(value[j]>value[j+1]) {
                    temp=value[j];
                    value[j]=value[j+1];
                    value[j+1]=temp;
                    flag=false;//即如果不发生交换
                }
                
            }
            if(flag) {
                break;//优化了
            }
            System.out.println(Arrays.toString(value));
        }
        
        
    }
}

二分法查找

import java.util.Arrays;
 
public class testbinarysearch {
    public static void main(String[]args) {
        int[]arr= {30,20,60,80,90,120,25,46,79,37,135};
        Arrays.sort(arr);//排序
        System.out.println(Arrays.toString(arr));
        
        System.out.println(test(arr,100));
        
        
    }
public static int test(int[]arr,int value) {
    int low=0;//最小的索引
    int hight=arr.length;//最大的索引
    while(low<=hight) {
        int mid=(low+hight)/2;//中间的索引
        if(value==arr[mid]) {
            return mid;
        }
        else if(value>arr[mid]) {
            low=mid+1;
        }
        else if(value<arr[mid]) {
            hight=mid-1;
        }
        
    }
    return -1;//如果arr中不包含此数，返回-1
    
}
}

8.1.1包装类
包装类均位于java.lang包

测试Integer类型

public class testwrappedclass {
    public static void main(String[]args) {
        //基本数据类型转成包装类对象
        Integer a=new Integer(3);
        Integer b=Integer.valueOf(30);
        //把包装类对象转成基本数据类型
        int c=b.intValue();
        double d=b.doubleValue();
        //把字符串转成包装类对象
        Integer e=new Integer("999");
        Integer f=Integer.parseInt("999888");
        //把包装类对象转成字符串类型
        String str=f.toString();//""+f
        //常见的常量
        System.out.println("int类型最大的整数："+Integer.MAX_VALUE);//输出int类型最大的整数：2147483647
 
    
    }
}

自动装箱和拆箱，缓存

public class testautobox {
    public static void main(String[]args) {
        Integer a=220;//自动装箱，相当于Integer a=Integer.valueOf(220);
        int b=a;//自动拆箱，相当于int b=a.intValue();
        Integer c=null;//调用c.intValue();引发空指针异常
        if(c!=null) {
            int d=c;
        }
        
        //缓存[-128,127]之间的数字，实际就是系统初始的时候，创建了[-128,127]之间的一个缓存数组
        Integer in1 = -128;
        Integer in2 = -128;
        System.out.println(in1 == in2);//true 因为123在缓存范围内
        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
    }
}

8.1.2.String类

public class teststring {
    public static void main(String[]args) {
        String str="aaaabbbccc";
        String st=str.substring(2,5);//substring()是对字符串的截取操作，但本质是读取原字符串内容生成了新的字符串
        System.out.println(str);
        System.out.println(st);
         //编译器做了优化,直接在编译的时候将字符串进行拼接
        String str1 = "hello" + " java";//相当于str1 = "hello java";
        String str2 = "hello java";
        System.out.println(str1 == str2);//true
        String str3 = "hello";
        String str4 = " java";
        //编译的时候不知道变量中存储的是什么,所以没办法在编译的时候优化
        String str5 = str3 + str4;
        System.out.println(str2 == str5);//false
    }
}

String类的常用方法：

1. String类的下述方法能创建并返回一个新的String对象: concat()、 replace()、substring()、 toLowerCase()、 toUpperCase()、trim()。

2. 提供查找功能的有关方法: endsWith()、 startsWith()、 indexOf()、lastIndexOf()。

3. 提供比较功能的方法: equals()、equalsIgnoreCase()、compareTo()。

4. 其它方法: charAt() 、length()。

StringBuilder
是一个可变的序列

构造方法：

public StringBuilder();创建一个空白可变字符串对象，不含有任何内容

public StringBuilder(String str）;根据字符串的内容，来创建可变字符串对象

public class teststringbuild {
    public static void main(String[]args) {
        //1.public StringBuilder();创建一个空白可变字符串对象，不含有任何内容
        StringBuilder sb=new StringBuilder();
        System.out.println("sb:"+sb);
        System.out.println("sb.length():"+sb.length());
        //2.public StringBuilder(String str）;根据字符串的内容，来创建可变字符串对象
        StringBuilder sb2=new StringBuilder("hello");
        System.out.println("sb2:"+sb2);
        System.out.println("sb2.length():"+sb2.length());
    }
}

2.StringBuilder的添加和反转方法

public class testbuilder {
    public static void main(String[]args) {
        //创建对象
        StringBuilder sb=new StringBuilder();
        //public StringBuilder append（任意类型）    添加数据，并返回对象本身
        StringBuilder sb2=sb.append("hello");
        System.out.println("sb:"+sb);
        System.out.println("sb2:"+sb2);
        System.out.println(sb==sb2);//true,说明返回对象本身
        //所以，下面是可以实现的
        sb.append(" world ");
        sb.append("java");
        System.out.println("sb:"+sb);//sb:hello world java
        //使用链式编程
        sb.append(" nihao ").append("shijie ").append("nice to meet you");
        System.out.println("sb:"+sb);//sb:hello world java nihao shijie nice to meet you
        
        
        //public StringBuilder reverse（）    返回相反的字符序列
        sb.reverse();
        System.out.println("sb:"+sb);//uoy teem ot ecin eijihs oahin avaj dlrow olleh
        
    }
}

StringBuilder 的常用方法

1. 重载的public StringBuilder append(…)方法

可以为该StringBuilder 对象添加字符序列，仍然返回自身对象。

2. 方法 public StringBuilder delete(int start,int end)

可以删除从start开始到end-1为止的一段字符序列，仍然返回自身对象。

3. 方法 public StringBuilder deleteCharAt(int index)

移除此序列指定位置上的 char，仍然返回自身对象。

4. 重载的public StringBuilder insert(…)方法

可以为该StringBuilder 对象在指定位置插入字符序列，仍然返回自身对象。

5. 方法 public StringBuilder reverse()

用于将字符序列逆序，仍然返回自身对象。

6. 方法 public String toString() 返回此序列中数据的字符串表示形式。

8.1.3Date时间类

Date中常用的方法：

1.public long getTime():获取的是日期对象从1970年1月1日00：00：00到现在的毫秒值

2.public void setTime(long time):设置时间，给的是毫秒值

3. boolean after(Date when) 测试此日期是否在指定日期之后

2.DateFormat类

作用：把时间对象转化成指定格式的字符串，反之，把指定格式的字符串转化成时间对象，DateFormat是一个抽象类，一般使用它的子类SimpleDateFormat来实现。

import java.util.Date;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
public class testdata {
    public static void main(String[]args) {
        Date d=new Date();
        System.out.println(d);
        DateFormat df=new SimpleDateFormat();
        
    }
}


import java.util.Date;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
public class testdata {
    public static void main(String[]args) throws ParseException {
        Date d=new Date();
        System.out.println(d);
        //把时间对象按照“格式字符串指定的格式”转成相应的字符串
        DateFormat df=new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss");
        String str=df.format(new Date(1000000));
        System.out.println(str);
        //把字符串按照“格式字符串指定的对象”转化成相应的对象
        DateFormat df2=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        Date d1=df2.parse("2022-05-16 14:45:30");
        System.out.println(d1);
        //测试其他
        DateFormat df3=new SimpleDateFormat("D");//今天是本年的第几天
        String str3=df3.format(new Date());
        System.out.println(str3);
        
    }
}

Calendar日历类

import java.util.Calendar;
import java.util.GregorianCalendar;
 
public class testCalendar {
    public static void main(String[]args) {
        Calendar ca=new GregorianCalendar(2099,5,16,12,10,30);
        int year=ca.get(Calendar.YEAR);
        int month=ca.get(Calendar.MONTH);
        int day=ca.get(Calendar.DATE);//也可以用DAY_OF_MONTH
        int week=ca.get(Calendar.DAY_OF_WEEK);//周几
        System.out.println(ca);
        System.out.println(year);
        System.out.println(month);
        System.out.println(day);
        System.out.println(week);
        
    }
}

注意：0-11表示月份，0是1月......11是12月。1-7表示星期日-星期六，1是星期日......7是星期六

//设置日期
        Calendar ca1=new GregorianCalendar();
        ca1.set(Calendar.YEAR, 2089);
        System.out.println(ca1.get(Calendar.YEAR));
        //日期的计算
        Calendar ca2=new GregorianCalendar();
        ca2.add(Calendar.YEAR, 100);//向后100年，向前100年是-100
        System.out.println(ca2.get(Calendar.YEAR));
        //日期对象和时间对象的转化
        Date d=ca2.getTime();//日期对象转化为时间对象
        Calendar ca3=new GregorianCalendar();
        ca3.setTime(new Date());//时间对象转化为日期类
        System.out.println(d);
        System.out.println(ca3);

可视化日历程序（1）

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
 
//可视化日历
public class testCalendar2 {
    public static void main(String[]args) throws ParseException {
        String str="2022-05-16";//字符串
        DateFormat df=new SimpleDateFormat("yyyy-MM-dd");
        Date date=df.parse(str);//把字符串转化成时间对象
        System.out.println(date);
        Calendar c=new GregorianCalendar();
        c.setTime(date);//把时间对象转化为日期
        //System.out.println(c.get(Calendar.DAY_OF_MONTH));
        System.out.println("日\t一\t二\t三\t四\t五\t六");
        c.set(Calendar.DAY_OF_MONTH,1);
        for(int i=0;i<c.get(Calendar.DAY_OF_WEEK)-1;i++) {//使得
            System.out.print("\t");
        }
        
        for(int i=1;i<=c.getActualMaximum(Calendar.DATE);i++)
        {
            System.out.print(c.get(Calendar.DAY_OF_MONTH)+"\t");
            
            if(c.get(Calendar.DAY_OF_WEEK)==7) {//如果为周六，则换行
                System.out.print("\n");
            }
            c.add(Calendar.DAY_OF_MONTH, 1);//依次加一
        }
    }
        
}

可视化日历程序（2）

package ba;
 
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Scanner;
 
//可视化日历
public class testCalendar2 {
    public static void main(String[]args) throws ParseException {
        System.out.println("请输入日期（格式为XXXX-XX-XX）：");
        Scanner scanner=new Scanner(System.in);
        String str=scanner.nextLine();//字符串
        DateFormat df=new SimpleDateFormat("yyyy-MM-dd");
        Date date=df.parse(str);//把字符串转化成时间对象
        System.out.println(date);
        Calendar c=new GregorianCalendar();
        c.setTime(date);//把时间对象转化为日期
        int day=c.get(Calendar.DAY_OF_MONTH);
        //System.out.println(c.get(Calendar.DAY_OF_MONTH));
        System.out.println("日\t一\t二\t三\t四\t五\t六");
        c.set(Calendar.DAY_OF_MONTH,1);
        for(int i=0;i<c.get(Calendar.DAY_OF_WEEK)-1;i++) {//使得
            System.out.print("\t");
        }
        
        for(int i=1;i<=c.getActualMaximum(Calendar.DATE);i++)//getActualMaximum获得本月最大天数
        {
            if(c.get(Calendar.DAY_OF_MONTH)==day) {
                System.out.print(c.get(Calendar.DAY_OF_MONTH)+"*"+"\t");
            }
            else {
                System.out.print(c.get(Calendar.DAY_OF_MONTH)+"\t");
            }
            
            
            if(c.get(Calendar.DAY_OF_WEEK)==7) {//如果为周六，则换行
                System.out.print("\n");
            }
            c.add(Calendar.DAY_OF_MONTH, 1);//依次加一
        }
    }
        
}

8.1.4 Math类
Math类的常用方法：

1. abs 绝对值

2. acos,asin,atan,cos,sin,tan 三角函数

3. sqrt 平方根

4. pow(double a, double b) a的b次幂

5. max(double a, double b) 取大值

6. min(double a, double b) 取小值

7. ceil(double a) 大于a的最小整数

8. floor(double a) 小于a的最大整数

9. random() 返回 0.0 到 1.0 的随机数

10. long round(double a) double型的数据a转换为long型(四舍五入)

11. toDegrees(double angrad) 弧度->角度

12. toRadians(double angdeg) 角度->弧度

8.1.5 Random类

public class TestRandom {
    public static void main(String[] args) {
        Random rand = new Random();
        //随机生成[0,1)之间的double类型的数据
        System.out.println(rand.nextDouble());
        //随机生成int类型允许范围之内的整型数据
        System.out.println(rand.nextInt());
        //随机生成[0,1)之间的float类型的数据
        System.out.println(rand.nextFloat());
        //随机生成false或者true
        System.out.println(rand.nextBoolean());
        //随机生成[0,10)之间的int类型的数据
        System.out.print(rand.nextInt(10));
        //随机生成[20,30)之间的int类型的数据
        System.out.print(20 + rand.nextInt(10));
        //随机生成[20,30)之间的int类型的数据（此种方法计算较为复杂）
        System.out.print(20 + (int) (rand.nextDouble() * 10));
    }
}

8.1.6.File类

File类常用的构造方法：public File(String pathname)

import java.io.File;
import java.io.IOException;
import java.util.Date;
 
public class testFile {
    public static void main(String[]args) throws IOException {
        File f=new File("D:/a.txt");
        //File f=new File("d:\\a.txt");
        System.out.println(f);
        f.renameTo(new File("D:\\dd.txt"));//改名
        System.out.println(System.getProperty("user.dir"));//打印该项目目录
        File f2=new File("dd.txt");
        f2.createNewFile();//在项目路径下创建文件
        
        System.out.println("File是否存在："+f2.exists());//File是否存在：true
        System.out.println("File是否是目录："+f2.isDirectory());//File是否是目录：false
        System.out.println("File是否是文件："+f2.isFile());//File是否是文件：true
        System.out.println("File最后修改时间："+new Date(f2.lastModified()));//File最后修改时间：Tue May 17 16:23:37 CST 2022
        System.out.println("File的大小："+f2.length());//File的大小：0
        System.out.println("File的文件名："+f2.getName());//File的文件名：dd.txt
        System.out.println("File的目录路径："+f2.getPath());//File的目录路径：dd.txt
        
        
    }
}

递归打印目录树

package d;
 
import java.io.File;
 
public class testdigui {
    public static void main(String[]args) {
        File f=new File("E:\\python");
        printfile(f,0);
    }
    static void printfile(File file,int level) {
        
        
        int sum = 0;
        //导出层次
        for(int i=0;i<level;i++)
        {
            sum=i;
        }
        System.out.print(sum);
        System.out.println(file.getName());//输出文件名
        
        if(file.isDirectory()) {//测试是否是目录
            File[]files=file.listFiles();//将子文件保存
        for(File temp:files) {//遍历
            printfile(temp,level+1);
        }
        }
    }
}

枚举

package d;
 
public class testmeiju {
    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{
    星期1,星期2,星期3,星期4,星5,星期6,星期7
}

m0_63513547

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java周记2

抽象类，抽象方法包含抽象方法的类就是抽象类。通过abstract方法定义规范，然后要求子类必须定义具体实现。通过抽象类，就可以做到严格限制子类的设计，使子类之间更加通用。抽象类的使用要点：有抽象方法的类只能定义成抽象类抽象类不能实现实例化，即不能用new来实例化抽象类抽象类可以包含属性、方法、构造方法，但是构造方法不能用来new实例，只能用来被子类调用抽象类只能用来被继承抽象方法必须被子类实现5.9.1接口接口是比抽象类还“抽象”的抽象类。声明格式：...
复制链接

扫一扫