java_03类和异常

最新推荐文章于 2023-03-31 22:35:42 发布

胖虎艾春辉

最新推荐文章于 2023-03-31 22:35:42 发布

阅读量243

点赞数

分类专栏：学生 java 文章标签： java_03类和异常

本文链接：https://blog.csdn.net/weixin_42479155/article/details/88779928

版权

学生同时被 2 个专栏收录

112 篇文章 0 订阅

订阅专栏

java

91 篇文章 1 订阅

订阅专栏

内部类:一个类A，定义在另外一个类B的内部，这个类A，被称为内部类
内部接口：一个接口A，定义在另外一个接口B的内部
访问外部类，按定义类对象一般来，外部类访问内部类需要: OutClass.InnerClass ic = new OuterClass().new InnerClass()

Object类

object类是类层次结构的根类
所有类都必须直接或者间接继承object类
两个重要方法：boolean equals(Object obj):比较两个对象是否相等，tostring()默认返回地址值：包名.类名@地址，注意：打印一个对象，底层先调用该对象的tostring方法，然后打印返回值

异常

是代码编译或者运行过程中出现的问题
继承体系：Throwable:可以抛出去的东西
1. Exception 异常（普通问题)
2. Error：错误，如果程序出现问题，只能对程序进行修改
模拟抛出异常：throw new Exception();
处理异常方法：
- 不处理，再次声明抛出：throw：动词，真正的抛出一个异常对象；throws，形容词，用来形容方的
- 捕获处理try catch finally语句等语句进行处理
- 其他处理方法：相当于多个try catch
注意：
1. 运行时候异常被抛出可以不处理，即不捕获也不声明抛出
2. 如果父类方法抛出多个异常，子类在覆盖父类时候，只能抛出相同异常或者是它的子集
3. 如果父类方法没有抛出异常，子类覆盖父类该方法时候也不可以抛出异常，此时子类产生该异常，只能捕获处理，不能声明抛出
4. 当多异常处理时，捕获处理，前面的类不能是后面的类的父类
5. finally中的语句一定会执行，通常使用释放资源
编译和运行异常介绍
1. 编译时异常Exception以及它的子类（RutimeException除外）
2. 运行时异常RutimeException以及它的子类
3. 区分：编译时异常编译时报错，运行时异常运行时报错
自定义异常类：
1. 创建一个类，这个类必须使用Exception结尾
2. 必须继承Exception或者RutimeExcepton
3. 至少有两个构造
  1. 空参数
  2. 带有string类型的参数的构造
Object方法是所有类的父类

代理模式（基于接口）

使用抽象类接口，让子类重写：

package java学习.异常;
//代理接口
public interface ComputerInterface {
    public abstract String buyComputer();
    public abstract void repair();
}
package java学习.异常;
//代理对象
public class ComputerCompany implements ComputerInterface{
    @Override
    public String buyComputer() {
        return "y45001T电脑，3888";
    }

    @Override
    public void repair() {
        System.out.println("免费修好了");
    }
}
package java学习.异常;

public class ProxyPerson implements ComputerInterface{
    private ComputerInterface lianxiang;
    @Override
    public String buyComputer() {
        return "鼠标，键盘，电脑包，u盘，操作系统,3000"+lianxiang.buyComputer();
    }

    @Override
    public void repair() {
        System.out.println("需要运费");
        lianxiang.repair();
    }
    public ProxyPerson(ComputerInterface lianxiang){
        this.lianxiang = lianxiang;
    }
}
package java学习.异常;

public class PtoxyDemo {
    public static void main(String[] args) {
        //被代理对象
        ComputerCompany lianxiang = new ComputerCompany();
        //代理对象
        ProxyPerson pp = new ProxyPerson(lianxiang);
        System.out.println(pp.buyComputer());
        pp.repair();
    }
}

包装类

基本数据类型包装类(基本数据类型–对应类型)
1. byte --Byte
2. boolean–Boolean
3. char–Character
4. short–Short
5. int–Integer
6. long–Long
7. float–Float
8. double–Double
使用用法区别：
1. 在集合中只允许存储包装类型，不能存储基本类型
2. 包装类里面可以实现类型转换，如果是基本类型强制转换会报错
Date类：
1. public Date() 代表当前系统时间的Date对象
2. public Date(long time) 代表距离标准时间time毫秒值的Date对象
3. public String toString()重写Object类的toString方法
4. public long getTime()获取当前Date对象的毫秒值
DateFormat：日期格式化类，是一个抽象类
1. 具体的子类：SimpleDateFormat
2. public SimpleDateFormat(String pattern);//以指定的模式创建格式化对象
3. public String format(Date d)把date对象按照指定的模式转成字符串
4. public Date parse(String s)把字符串转成Date对象，如果字符串有问题，抛出异常
Calendar对象
1. public static Calendar getInstance()返回抽象类Calendar的某一个子类
2. public int get(int field)获取指定字段的值
3. public void add(int field,int amount)给指定的字段增加值
4. public void set(int field,int value)修改指定字段的值
5. public Date getTime()把Calendar对象转化为Date对象
System：系统类
1. public static void exit(0)结束jvm
2. public static void gc()回收垃圾
3. public static getProperty(String key)根据键获取值
4. public static long currentTimeMillis()获取当前系统的毫秒值
Math：数学类

自动拆箱和自动装箱

拆箱：包装类型—基本类型
装箱：基本类型–包装类型
Integer i=10;自动的把10这个基本类型装成Integer类型
i++;i = (i+1)（Integer +int) --(int+int)实际上的作用是，先拆箱再装箱

在string类中有一个方法：public string[] split(string s);切割字符串，返回切割后的字符串数组

String phone = "2-3--4----05";
String[] result = phone.split("-+");
        for (String n:result) {
            System.out.println(n);
        }

集合

Collection根接口中定义的方法：这些方法，所有的集合类都具有
1. boolean add(E e)添加某一个元素，返回值表示是否成功
2. boolean remove(Object obj)删除某个元素，返回值表示是否删除成功
3. int size()获取长度
4. void clear()删除所有元素
5. Object[] toArray()集合转化为数组
如何创建一个集合元素，使用多态：Collection names = new ArrayList()

集合的遍历：在根接口中，使用了一种公共的遍历方式，迭代器遍历

获取一个迭代器对象（迭代器对象不是我们创建的，而是每一个集合自带的

public static void main(String[] args) {
        Collection<String> name = new ArrayList<String>();
        name.add("1");
        name.add("2");
        name.add("3");
       Iterator<String> it =  name.iterator();//获取集合的迭代器对象
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
    }

在这里插入图片描述

java规定，如果一个集合使用迭代器遍历，那么在遍历过程中，不允许修改集合的长度（增加或者删除）

泛型

泛型，不确定的类型，,E只是占位符的作用
泛型用来灵活的将数据类型应用的不同的类、方法、接口中
泛型的好处：
1. 将运行时期的ClassCastException转移到了编译时期变成了编译失败
2. 避免了强制类型转换
泛型中E的含义：E的本质是一个变量，用来储存数据类型

泛型可以用在类中、方法中、接口中；是一个不确定的类型，当你创建类的对象时候可以自动确定

public class GenericDemo<E> {
    E aaa;
    public static  void demo01(){
        
    }
    public void setA(E aaa){
        this.aaa = aaa;
    }
}----泛型类
  public <t> void setA(t aaa){
    }---泛型方法，在调用方法时候确定类型

泛型方法用在接口上：泛型接口
- public interface 接口名
- 当子类实现接口时候，确定接口上的泛型
- 当子类实现接口时候，还是不确定泛型，把接口的泛型继续实现下来，当实现类创建对象时候确定

泛型通配符：

通配符：正则表达式中，“.”代表任意内容

泛型通配符：？代表任意类型实例：？extend Animal表示的是一种泛型，这种泛型必须是Animal或者Animal的子类，？super Animal代表它或者它的父类

    public static void main(String[] args) {
        //第一个集合
        ArrayList<String> name1 = new ArrayList<String>();
        name1.add("111");
        name1.add("222");
        name1.add("333");
        //第二个集合
        ArrayList<String> name2 = new ArrayList<String>();
        name1.add("aaa");
        name1.add("bbb");
        name1.add("ccc");
        name1.addAll(name2);
        System.out.println(name1);
        //第三个集合
        ArrayList<Integer> name3 = new ArrayList<Integer>();
        name3.add(123);
        name3.add(456);
        name3.add(789);
    }

集合框架
- 根接口：Collection
- 子接口：List，Set，Queue
Collection中是没有下标的，在Collection中定义了一个公共的遍历方式：迭代器遍历
无论使用foreach还是迭代器遍历，在查询过程中不能修改集合的长度，否则抛出异常

Map集合特点

Map集合和Collection集合没有继承关系，所以不能直接使用迭代器
Collection集合每一个元素都是单独存在，Map集合的每一个元素都是成对存在的
Collection一个泛型，Map<K,V> ,K代表键的类型，V代表值的类型，K，V可以相同，也可以不同，必须是引用类型
在Map集合的元素中，键是唯一的，值可以是重复的
HashMap<K,V>：存储数据采用的是哈希表结构，元素的存取顺序不能保证一致，由于要保证键的唯一、不重复，需要重写键的hashCode方法，equals方法
LingkedHashMap<K,V>：是HashMap的一个子类，存储数据采用的是哈希表结构和链表结构，通过链表结构可以保证元素的存取顺序一致，通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode方法，equals方法
常用方法：
1. 增：put(K key,V value),如果集合中已经存在该键，覆盖整个键值对，并返回被覆盖键值对的值
2. 删：remove(Objeck key)//键是唯一的，值是可以重复的,返回值表示被删除的键值对的值
3. 改：可以使用put方法覆盖
4. 查：get(Object key);返回值是通过键找到的对应的值

Map集合遍历方式：

键找值：keyset()获取所有的键的集合，遍历键的集合，可以foreach或者迭代器，然后通过遍历的键，直接寻找相应的值

		//键值对
        Map<String,String> map = new LinkedHashMap<String, String>();
        map.put("1","a");
        map.put("2","b");
        map.put("3","c");
        String v = map.put("1","v");
        System.out.println(map);
        System.out.println(v);
        Set<String> keys = map.keySet();
        Iterator<String> it = keys.iterator();
        while (it.hasNext()){
            String s = it.next();
            String value = map.get(s);
            System.out.println(s+" "+ value);
        }

键值对遍历：获取map集合中所有的键值对对象

        Map<String,String> map = new LinkedHashMap<String, String>();
        map.put("1","a");
        map.put("2","b");
        map.put("3","c");
        //获取所有键值对关系对象的集合
        Set<Map.Entry<String,String>> entrySet = map.entrySet();
        System.out.println(entrySet);

如果Map中的键是自定义类型，那么要保证键的唯一性，必须重写键对应类的hashCode方法和equals方法

Properties属性集合

是一个持久的属性集，它具有自己写数据到文件的方法
Propertics没有泛型，固定是String和String
Properties类，具有Map接口的一切方法，同时还具有自己特有的方法：
1. public String getProperty(String key)用指定的键在此属性列表中搜索属性
2. public Object setProperty(String key,String value)调用Hashtable 的方法put
3. public Set stringPropertyNames()返回此属性列表中的键集
Properties具有持久化到文件的功能
1. store()//保存数据到文件
2. load()//从文件中加载数据

Collection中的静态方法：

1. public static void suffle()打乱顺序
2. public static void sort()排序

总结

Map集合是双列集合，Map集合没有迭代器，因为Map不是继承Collection
Map集合元素的键是不能重复的，值可以重复
实现类：HashMap无序 LinkedHashMap有序
遍历：
1. keySet：以键找值
2. entry：键值对对象
Properties,全名：class Properties extends HashTable extends Dictionary Implements Map就是一个属性集
1. setProperty(String key,String value) put方法
2. getProperty(String key) get方法
3. stringPropertyNames();keySet方法
4. store方法，保存数据到文件，实际上不是写入文件，是先写入流中，由流写入文件，实例：ps.store(new FileWriter(“phones.properties”), “艾春辉”);
5. load方法，读取数据，实际上是将数据读入流中，在从流中读取数据

案例（斗地主）

package java学习.Map;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

public class DoDiZhu {
    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<Integer, String>();
        ArrayList<Integer> cards = new ArrayList<Integer>();
        int id = 54;
        String[] colors = {"♥", "♠", "♣", "♦"};
        String[] nums = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K","A","2"};
       for (String num:nums){
            for (String color:colors){
                map.put(id,color+num);
                cards.add(id);
                id--;
            }
        }
        map.put(id,"小王");
       cards.add(id);
        id--;
        map.put(id,"小王");
        cards.add(id);
        Collections.shuffle(cards);
        ArrayList<Integer> p1 = new ArrayList<Integer>();
        ArrayList<Integer> p2 = new ArrayList<Integer>();
        ArrayList<Integer> p3 = new ArrayList<Integer>();
        ArrayList<Integer> dp = new ArrayList<Integer>();
        for (int i = 0;i < cards.size();i++){
            int card = cards.get(i);
            if (i>=51){
                dp.add(card);
                continue;
            }
            if (i%3==0){
                p1.add(card);

            }else if (i%3==1){
                p2.add(card);
            }else{
                p3.add(card);
            }
        }
        Collections.sort(p1);
        Collections.sort(p2);
        Collections.sort(p3);
        Collections.sort(dp);
        lookCards(p1,map);
        lookCards(p2,map);
        lookCards(p3,map);
        lookCards(dp,map);
    }
    public static void lookCards(ArrayList<Integer> p,Map<Integer,String> map){
        //从map中查询对应的排
        for (Integer n:p) {
            String card = map.get(n);
            System.out.print(card +" ");
        }
        System.out.println();
    }
}

数组工具类

public static List asList()把一个数转化成list
public static void sort()排序
public static String toString(数组)把数组转化为字符串

案例：需要定义一个集合，保存学生学号和对应名字

package java学习.File;

import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;

public class Test1 {
    public static void main(String[] args) {
        //存储javaee集合
        //存储ui集合
        //存储pp集合
        Map<String,String> eeMap = new LinkedHashMap<String, String>();
        eeMap.put("001","张三");
        eeMap.put("002","李四");
        eeMap.put("003","王五");
        Map<String,String> uiMap = new LinkedHashMap<String, String>();
        uiMap.put("003","小一");
        uiMap.put("004","小二");
        uiMap.put("005","小三");
        Map<String,String> ppMap = new LinkedHashMap<String, String>();
        ppMap.put("001","张");
        ppMap.put("002","李");
        ppMap.put("003","王");
        Map<String,Map<String,String>> czMap = new LinkedHashMap<String, Map<String, String>>();
        czMap.put("ee",eeMap);
        czMap.put("ui",uiMap);
        czMap.put("pp",ppMap);
        //遍历
        Set<Map.Entry<String,Map<String,String>>> czSat = czMap.entrySet();
        Iterator<Map.Entry<String,Map<String,String>>> czit = czSat.iterator();
        while (czit.hasNext()){
            Map.Entry<String,Map<String,String>> czentry = czit.next();
            String czKey = czentry.getKey();
            Map<String,String> czValue = czentry.getValue();
            System.out.println(czValue);
            //然后因为值也是一个键值对，所以我们仍然需要遍历取出其中的值
            //第一种方法以键找值，第二种方法通过键值对找值
            Set<String> Keys = czValue.keySet();
            for (String num:Keys) {
                System.out.println(num);
            }
        }
    }
}