Java学习--API和异常

大面积秃头

于 2022-09-28 19:33:47 发布

阅读量231

点赞数

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

本文链接：https://blog.csdn.net/wode39/article/details/127095518

版权

笔记同时被 2 个专栏收录

28 篇文章 0 订阅

订阅专栏

java

18 篇文章 0 订阅

订阅专栏

Api和异常

概述：

内部类：就是在一个类中定义一个类。在类A中定义一个类B，B就叫做A的内部类

格式：

public calss 类名{
	修饰符 class 类名{

	}
}

//范例
public class Outer{
	public  class Inner{
	
	}
}

内部类的访问特点：

内部类可以直接访问外部类的成员，包括私有

外部类要访问内部类的成员，必须创建对象

//内部类可以访问外部类的成员 ，包括私有
//外部类要访问内部类的成员必须要创建对象
public class Outer{
    private int num=10;
    public class Inner{
        public void show(){
            System.out.println(num);
        }
    }
    public void method(){
       // show();
       Inner i=new Inner();
        i.show();
    }
}

内部类的分类：按照内部类在类中定义的位置不同，可分为如下两种形式：

在类的成员位置：成员内部类

在类的局部位置：局部内部类

成员内部类，外界如何创建对象使用呢？

格式：外部类名.内部类名对象名=外部类名.内部类对象；

public class Outer{
    private int bum=10;
    public  class Inner{
        public void show(){
            System.out.println(num);
        }
    }
}

public class Test{
    public stastic void main(String[] args){
        //创建内部类对象，调用方法
        Outer.inner oi=new Outer().new Inner();
        oi.show();
    }
}

以上这种方法不常见，通常内部类是私有的，此时测试类要调用内部类的方法要分两步骤：

1.在外部内创建一个方法，实例化内部类

2.测试类实例化外部类，通过外部类对象调用方法

public class Outer{
    private int num=10;
    private class Inner{
        public void show(){
            System.out.println(nun);
        }
        
    }
    
    //提供一个方法，创建内部类对象
    public void method(){
        Inner i=new Inner();
        i.show();
    }
}

public class Test{
    Outer o=new Outer();
    o.method();
}

局部内部类：

要调用局部内部类的方法，必须先实例化局部内部内的对象

public class Outer{
    private int num=10;
    public void method(){
        class Inner{
            public void show(){
                System.out.println(num);
            }
        }
        //局部内部类的实例化
        Inner i=new Inner();
        i.show;
    }
    
    
}

public class Test{
    public class void main(String[],args){
        Outer o =new Outer();
        o.method();
    }
}

由上图可知，局部内部类是在方法中定义的类，所以外界无法直接使用，需要在方法内部创建对象并使用

该类可以直接访问外部类成员，也可以访问方法内的局部变量。

匿名内部类

前提：存在一个类或者接口，这里的类可以使具体的类也可以是抽象类

格式

new 类名或者接口名(){
	重写方法;
}

//范例
new Inter(){
    public void show(){}
}

本质：是一个继承了该类或者实现了该接口的子类匿名对象

public class Outer{
	public void method(){
		/*new Inter(){
            show(){
				System.out.println("匿名内部类！");
            }
		}.show();
		*/
		Inter i=new Inter(){
            show(){
				System.out.println("匿名内部类！");
            }
		};
		i.show();
		i.show();
	}
}

//创建一个接口
public interface Inter{
	void show();
}

//测试类
public class Test{
	public static void main(String [] args){}
}

基本类型包装类

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据

常用的操作之一：用于基本数据类型与字符串之间的转换

Integer类

Integer：包装一个对象中的原始类型int的值

Integer i1=Integer.valueOf(100);//表示返回指定int的值得Integer实例

Integer i2=Integer.valueOf(“100”);//表示返回一个保存指定值得Integer对象 String

int和String之间的相互转换

int nunber=100;

//方式一：实质是做字符串的拼接
String s1=""+number;
System.out.println(s1);

//方式二：
//public static String valueOf(int i) 返回int参数的字符串形式
String s2=String.valueOf(number);
System.out.println(s2);

//把String类型的转换为int类型

String s="100";
//方式一：先把String类型转换成Integer，在转换为int
Integer i=Integer.valueOf(s);
//public int intValue()
int x=i.intValue();
System.out.println(x);

//方式二：public static int parseInt(String s)
int m=Integer.parseInt(s);
System.out.println(m);

字符串中的数据排序

//思路：1.定义一个字符串 
String s="21 89 73 9 34 19";
//2.把字符串中的数字存储到一个int类型的数组中

//得到字符串中每一个数字数据
//public String[] split(String regex)
String[] str=s.split(" ");


//定义一个int数组，把String[]数据组中的每一个元素存储到int数组中

// public static parseInt(String s)
int [] arr=new int[str.length];
for(int i=0;i<str.length;i++){
     arr[i]=Integer.parseInt(str[i]);
}

//对int数组进行排序
Arrays.sort(arr);

//把排序后的int数组中的元素进行拼接得到一个字符串，这里拼接采用StringBuilder来实现
StringBuilder sb=new StringBuilder();
for(int i=0;i<arr.length;i++){
    //判断是否为最后一个元素
    if(i==arr.length-1){
        sb.append(arr[i]);
    }else{
        sb.append(arrp[i].append(" "));
    }
    
    //将StringBuilder类型的数据转换成String
    String res=sb.toString();
}

//输出结果
System.out.println("result="+res);

Arrays(应用)

方法名	说明
public static String toString(int[] a)	返回指定数组的字符串表示形式
public stastic void sort(int []a)	按照数字顺序排列指定的数组

工具类设计思想

1、构造方法用private 修饰

2、成员方法用public static 修饰

自动装箱和拆箱

装箱：把基本数据类型转换成对应的包装类类型

拆箱：把包装类类型转换为对应得基本数据类型

注意：在使用包装类类型得时候，如果做操作，最好先判断是否为null

只要是对象，在使用前就必须进行不为空的判断

Date类

Date类概述：

Date代表了一个特定的时间，精确到毫秒

Date类的构造方法

方法名	说明
public Date()	分配一个 Date对象，并初始化，以便它代表它被分配的时间，精确到毫秒
public Date(long date)	分配一个 Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数

public class DateDemo01 {
    public static void main(String[] args) {
       //public Date():分配一个Date对象，并初始化，以便它代表它被分配的时间精确到毫秒
        Date d1=new Date();
        System.out.println(d1);
        //public Date(long date)：分配一个Date对象，并将其初始化为标准基准时间起指定的毫秒数
        long date=1000*60*60;
        Date d2=new Date(date);
        System.out.println(d2);
    }
}

Date类的常用方法（应用）

常用方法

方法名	说明
public long getTime()	获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值
public void setTime(long time)	设置时间，给的是毫秒值

public class DateDemo02 {
    public static void main(String[] args) {
        //创建日期对象
        Date d = new Date();

        //public long getTime():获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值
//        System.out.println(d.getTime());
//        System.out.println(d.getTime() * 1.0 / 1000 / 60 / 60 / 24 / 365 + "年");

        //public void setTime(long time):设置时间，给的是毫秒值
//        long time = 1000*60*60;
        long time = System.currentTimeMillis();
        d.setTime(time);

        System.out.println(d);
    }
}

SimpleDateFormat类

SimpleDateFormat类的概述

SimpleDateFormat是一个具体的类，用于以区域设置敏感的方式格式化和解析日期

方法名	说明
public SimpleDateFormat()	构造一个SimpleDateFormat，使用默认模式和日期格式
public SimpleDateFormat(String pattern)	构造一个SimpleDateFormat使用给定的模式和默认的日期格式

SimpleDateFormat类的常用方法

格式化（Date to String）

public final String formay(Date date):将日期格式化乘日期/时间字符串

解析（String to Date）

public Date parse(String sourse):从给定的字符串开始解析文本以生成日期

public class SimpleDateFormatDemo {
    public static void main(String[] args){
		//格式化 Date to String
        Date d=new Date();
        SimpleDateFormat sdf=new SimpleDateFormate("yyyy年MM月dd日 HH:mm:ss");
        String s=sdf.format(d);
        System.out.println(s);
        System.out.println("--------");
        //解析 String to Date
        String ss="2048-08-09 11:11:11";
        SimpleDateFormat sdf2=newSimpleDateFormate("yyyy-MM-dd HH:mm:ss");
        Date dd=sdf2.parse(ss);
        System.out.println(dd);
        
        
    }
}

日期工具类案例（应用）

定义一个日期工具类，包含两个方法，把日期转换为指定格式的字符串；把字符串解析成指定格式的日期，然后定义一个测试类DateDemo,测试日期工具类的方法

代码实现：

import java.text.ParseException;
import java.util.Date;

public class Test {
    public static void main(String[] args) throws ParseException {
        Date d=new Date();
        String s1 = DateUtils.dateToString(d, "yyyy年MM月dd日 HH:mm:ss");
        System.out.println(s1);
        String s2=DateUtils.dateToString(d,"yyyy年MM月dd日");
        System.out.println(s2);
        String s3=DateUtils.dateToString(d,"HH:mm:ss");
        System.out.println(s3);

        String time="2048-08-09 12:12:12";
        Date dd=DateUtils.stringToDate(time,"yyyy-MM-DD HH:mm:ss");
        System.out.println(dd);

    }
}

public class DateUtils {
    //无参构造
    private DateUtils(){}

    public static String dateToString(Date date, String format){
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat(format);
        String s=simpleDateFormat.format(date);
        return s;
    }

    public static Date stringToDate(String s,String format) throws ParseException {
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat(format);
        Date date=simpleDateFormat.parse(GFDs);
        return date;
    }
}

Canlendar类（应用）

Calendar类的概述

Calendar 为特定瞬间与一组日历字段之间的转换提供了一些方法，并为其操作日历字段提供了一些方法

Calendar 提供了一个类方法getIntstance用于获取这种类型一般有用的对象。

该方法返回一个Calendar对象。

其日历字段已使用当前日期和时间初始化：Calendar rightNow=Calendar.getInstance();

Calendar类的常用方法

方法名	说明
public int get(int field)	返回给定日历字段的值
public abstract void add(int field,int amount)	根据日历的的规则，将指定的时间量添加或减去给定的的日历字段
public final void set(int year,int month,int date)	设置当前日历的年月日

 System.out.println("请输入年份：");
        Scanner sc=new Scanner(System.in);
        int year=sc.nextInt();

        //创建一个calendar对象
        Calendar calendar=Calendar.getInstance();
        //设置当前时间为3月1日
        calendar.set(year,2,1);

        calendar.add(Calendar.DATE,-1);
        int date= calendar.get(Calendar.DATE);
        System.out.println(year + "年的2月份有" + date + "天");

public class Example {
    public static void main(String[] args) {
        //获取日历对象
        Calendar calendar=Calendar.getInstance();

        //public int get(int field)返回给定日历字段的值
        int year=calendar.get(Calendar.YEAR);
        int month=calendar.get(Calendar.MONTH)+1;
        int date=calendar.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");


        //public abstract void add(int field, int amount):根据日历的规则，将指定的时间量添加或减去给定的日历字段
        //需求1:3年前的今天
//        calendar.add(Calendar.YEAR,-3);
//        year = calendar.get(Calendar.YEAR);
//        month = calendar.get(Calendar.MONTH) + 1;
//        date = calendar.get(Calendar.DATE);
//        System.out.println(year + "年" + month + "月" + date + "日");

        //需求2:10年后的10天前
//        calendar.add(Calendar.YEAR,10);
//        calendar.add(Calendar.DATE,-10);
//        year = calendar.get(Calendar.YEAR);
//        month = calendar.get(Calendar.MONTH) + 1;
//        date = calendar.get(Calendar.DATE);
//        System.out.println(year + "年" + month + "月" + date + "日");

        //public final void set(int year,int month,int date):设置当前日历的年月日
        calendar.set(2050,10,10);
        year = calendar.get(Calendar.YEAR);
        month = calendar.get(Calendar.MONTH) + 1;
        date = calendar.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");
    }
}

异常

异常概述：程序出现了不正常的情况

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LBliwObU-1664364744040)(C:\Users\QQ363\AppData\Roaming\Typora\typora-user-images\image-20220928082806200.png)]

Error:严重问题，不需要处理

Exception:异常类，表示程序本身可以处理的问题

RutimeException:在编译期间不检查，出现问题后，需要回来修改代码

非RuntimeException:编译期间就必须处理，否则程序不能通过编译，就更不能正常运行

JVM的默认处理方案

如果程序出现了异常，JVM会做默认的处理

把异常的名称，异常原因及异常出现的位置等信息输出在控制台

程序停止执行

异常处理

异常处理之try…catch…

格式：

try{
	可能出现异常的代码
}catch(异常类名 变量名){
	异常处理的代码
}

执行流程

程序从try里面的代码开始执行

出现异常，会自动生成一个异常类对象，该异常类对象将被提交给Java运行时系统

当Java运行是系统会接收到异常对象，回到catch中去找匹配的异常类，找到后进行异常处理

执行完毕，程序还可以继续往下执行

Throwable的成员方法

方法名	说明
public String getMessage()	返回此throwable的详细消息字符串
public String toString()	返回可能抛出的简短描述
public void pritStackTrace()	把异常的错误信息输出在控制台

编译时异常和运行时异常

Java中的异常被分为两大类：编译时异常和运行时异常，也被称谓受检异常和非受检异常

所有的RuntimeExcption类及其子类被称为运行时异常，其他的异常都是编译时异常

编译时异常：必须显示处理，否则程序就会发生错误，无法通过编译

运行时异常：无需显示处理，也可以和编译时异常一样处理

异常处理之throws

程序中用throws抛出异常

注意：这个格式是跟在方法的括号后面的

编译时异常必须要进行处理，两种方案：try…catch…或者throws，如果采用throws这种方案，将来谁调用谁处理

运行时异常可以不处理，出现问题后，需要我们回来修改代码

自定义异常

格式：

public class 异常类名 extends Exception{
	无参构造
     带参构造
}

public class ScoreException extends Exception{
    public ScoreException{}
    ScoreException(String message){
		super(message);
    }
}

在方法体内部抛出异常对象用throw

throws 和throw的区别

throws	throw
用在方法申明后面，跟的是异常类名	用在方法体内部，跟的是异常对象名
表示抛出异常，由该方法调用者来处理	表示抛出异常，由方法体内的语句处理
表示出现异常的可能性，并不一定会发生那个这些异常	执行throw 一定是抛出了某种异常

public class 异常类名 extends Exception{
	无参构造
     带参构造
}

public class ScoreException extends Exception{
    public ScoreException{}
    ScoreException(String message){
		super(message);
    }
}

在方法体内部抛出异常对象用throw

throws 和throw的区别

throws	throw
用在方法申明后面，跟的是异常类名	用在方法体内部，跟的是异常对象名
表示抛出异常，由该方法调用者来处理	表示抛出异常，由方法体内的语句处理
表示出现异常的可能性，并不一定会发生那个这些异常	执行throw 一定是抛出了某种异常