欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Java基础提升高级API---百知教育java基础学习3

程序员文章站 2022-06-27 23:30:02
Java基础提升高级API—百知教育java基础学习3https://www.bilibili.com/video/BV1pE41137JY目录P1-Object类 15:41P2-Object类中的方法-1 1:08:32P3-Object类中的方法-2 55:06P4-包装类 49:17P5-Object类习题课 45:36P6-日期处理 24:56P7-String类的用法 1:04:47P8-String习题课 25:58P9-字...

Java基础提升高级API—百知教育java基础学习3
https://www.bilibili.com/video/BV1pE41137JY

Java基础提升高级API---百知教育java基础学习3函数接口回调 — todo day10

Java基础提升高级API---百知教育java基础学习3Java基础提升高级API---百知教育java基础学习3

Java基础提升高级API---百知教育java基础学习3

目录

P1-Object类    15:41
P2-Object类中的方法-1    1:08:32
P3-Object类中的方法-2    55:06
P4-包装类    49:17
P5-Object类习题课    45:36
P6-日期处理    24:56
P7-String类的用法    1:04:47
P8-String习题课    25:58
P9-字符串常量池    1:04:48
P10-集合的概念    48:30
P11-List的常用方法    35:27
P12-List的四种遍历方式    1:13:15
P13-泛型    45:57
P14-List的实现类    33:44
P15-Set集合    1:23:26
P16-Map集合    1:14:55
P17-集合习题课    1:01:16
P18-JDK5中的语法    44:22
P19-异常的分类    1:08:31
P20-异常的产生和传递    23:56
P21-声明抛出异常    55:41
P22-捕获异常    1:05:23
P23-IO流的分类    43:34
P24-字节流-1    25:39
P25-字节流-2    34:57
P26-缓冲字节流    1:16:22
P27-对象序列化    40:25
P28-对象的克隆    1:04:49
P29-字符编码与乱码问题    1:12:26
P30-字符流    33:46
P31-File类    20:06
P32-IO习题课    42:45
P33-多线程的基本编程    1:01:23
P34-线程的基本状态    35:57
P35-线程的阻塞    22:40
P36-线程池    1:01:04
P37-Callable和Future接口    54:46
P38-多线程的同步    1:06:12
P39-同步代码块    58:42
P40-同步方法    11:13
P41-线程安全的集合    50:24
P42-队列接口    31:51
P43-死锁问题    28:59
P44-类对象    56:58
P45-反射的应用    1:08:47
P46-单例设计模式    55:02
P47-工厂设计模式    42:55

类和包装类

P1-Object类 15:41

Object类,所有类的父类
如果一个类没有指定父类,默认继承Object类 
Object o = 任何对象 
Object o != 8种基本类型(byte short int long float double char boolean)
Object 类中定义的方法,是所有java对象都具有的方法  (public protected)

P2-Object类中的方法-1 1:08:32

P3-Object类中的方法-2 55:06

Java基础提升高级API---百知教育java基础学习3

方法名 作用 备注
getClass() 获得对象的实际类型 o1.getClass()=o2.getClass(); 判断类型是否相同
finalize() 在对象被垃圾回收时调用 没有典型的使用场景
toString() 返回对象的字符串形式 System.out.println(o); 等于System.out.pringln(o.toSTring());
equals 判断两个对象的内容是否相同 o1.equals(o2) 判断o1和o2内容是否相同

垃圾自动收集:由JVM的垃圾收集器自动回收垃圾对象,释放对象的堆空间
问:什么对象被认为是垃圾对象?
答:零引用算法 如果一个对象,没有任何对象引用它,就判断它是垃圾
问: 垃圾对象何时被回收?
答:不得不回收时候,才回收(全家人一起吃饭,刷碗要等到所有人吃完饭以后一起刷,不会一个人吃饭饭后,刷一个碗)
问:finalize() 具体作用?
答: 没有什么作用
JVM规范
JVM产品

System.gc(); //呼吁垃圾回收器,开始收集垃圾

toString()
返回对象的字符串形式
打印一个对象,就是打印这个对象toString()方法的返回值String
可以在子类覆盖toString();方法

== 用在引用类型时候判断地址是否相同
equals 判断内容是否相同 s1.equals(s2) 说明s1 s2 内容相同
object类中的equals方法,依然比较两个对象的地址

getClass() 获得对象实际类型
instanceof 判断对象是不是某一类型 a instanceof Animal ; a instance of Dog ;

equals 标准写法


 public boolean equals(Object o){
        // 是否同一个对象
       // 是否非Null
       // 是否同一类
       // 强转
       // 属性比较
   }


  //this     vs  o  比较内容
   public boolean equals(Object o){
        //1 判断 this    o  是不是同一对象  ,你媳妇 和你孩子他妈
       if(this == o ) return true;
       //2 判断o 是不是Null
       if(o ==null) return false;
       //3 判断this    o  是不是属于同一个类
       if(this.getClass() != o.getClass()) return false;
       // 4  对o 做强制类型转化,变为 Employee 类型
       Employee e =(Employee) o;
       // 5 逐个比较属性  基本类型用 == 引用类型 用equals
       if(this.age == e.age && this.name.equals(e.name)) {
           return true;
       }else{
           return false;
       }
   }

P4-包装类 49:17

Object o= 任何对象
Object o =10; error

为8中基本数据类型 各自提供一个类(8个类,是8个基本类型的对象形式)
所有的基本数据类型就有了对应的对象形式

int ---- > Integer

基本类型 对应的包装类
int Integer
char Charactor
byte Byte
short Short
long Long
float Float
double Double
boolean Boolean
  • 基本类型 与 包装类之间的转换
    int — > Integer
    Integer.valueOf(i); 获得一个Integer对象
    Integer内部会预先创建 -128 ~ 127 256个对象,如果在此区间不会创建新对象
    Integer —> int
    a.intValue();
    从jdk5开始,编译器帮助我们,自动封箱、自动拆箱 ;
    虚拟机还是会区分,什么是基本类型 ,什么是 对象(包装类) ;
  • 基本类型与String之间的转换 (这块用的多 )
    int ----> String
    int i=12; String s=i+"";
    String s =String.valueof(i);
    String----> int
    String s=“123456”; int i=Integer.ParseInt(s);
  • 包装类与String之间的转换
    Integer ----> String
    Integer a=1234; String s = a.toString(); //是对象所以有Object的toString()方法 ;
    String ----> Integer
    String s =“1234”; Integer a =Integer.valueof(s);

P5-Object类习题课 45:36

修饰符总结

表格 方法 构造方法 成员变量 局部变量 初始代码块 成员内部类
private
默认
protected
public
static
final
abstract

Java基础提升高级API---百知教育java基础学习3

  System.out.println("=================================");
        int a1=new Integer(128);
        int a2=new Integer(128);
        System.out.println(a1== a2);              //true  比较的是值 所以 true

        Integer integer1 = Integer.valueOf(a1);
        Integer integer2 = Integer.valueOf(a2);  //a1  a2 都不影响结果
        System.out.println(integer1==integer2);  //false  比较的是对象  且128 不在-128~127  需要单独创建

        Integer int1=new Integer(120);
        Integer int2=new Integer(120);
        System.out.println(int1==int2);          //false  比较对象

        Integer integer11 = Integer.valueOf(int1);
        Integer integer12 = Integer.valueOf(int2);//int1 int2  都不影响结果
        System.out.println(integer11==integer12);  //true   在-128~127  无需单独创建

        Integer int3 = new Integer(128);
        Integer int4 = new Integer(128);
        System.out.println(int3==int4);            //false  比较对象
        System.out.println("=================================");

P6-日期处理 24:56

package day16;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;

/**
 * @author leowei
 * @date 2020/12/29  - 13:40
 */
public class TestCalendar {
    public static void main(String[] args) {

        // *******
        long timeNowLong = System.currentTimeMillis();       // 距离 1970 年 的毫秒数
        System.out.println("timeNow = " + timeNowLong);

        // *******
       // Calendar c = Calendar.getInstance();
        Calendar c = Calendar.getInstance(Locale.FRANCE);  //
        Date timeNow = c.getTime();
        System.out.println("timeNow = " + timeNow);

        // *******
        c.setTimeInMillis(timeNowLong);
        int year = c.get(Calendar.YEAR);
        int dayM = c.get(Calendar.DAY_OF_MONTH);
        int dayY = c.get(Calendar.DAY_OF_YEAR);
        int dayW = c.get(Calendar.DAY_OF_WEEK);
        int daySpe =c.getFirstDayOfWeek();
        System.out.println("dayW: " + dayW+ " ;  dayMonth:"+ dayM + "; dayYear:"+ dayY + " ; year: "+ year +"; firstDayofWeek:"+ daySpe);
        //dayW: 3 ;  dayMonth:29; dayYear:364 ; year: 2020; firstDayofWeek:1
        // *******
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String formatTime = sdf.format(timeNow);
        System.out.println("formatTime = " + formatTime);



    }
}

P7-String类的用法 1:04:47

凡是没有数值含义的数字,一定不要把它当数值类型。

字符串中的常用方法

  • 与字符数组相关操作
    String(char[] cs) 利用字符数组构造字符串
    toCharArray() 把字符串转字符数组
  • 基础方法
    toUpperCase()
    toLowerCase()
    charAt(int index)
    length()
    trim();
    equals();
    equalsIgnoreCase();//忽略大小写比较,使用场景 验证码
  • 与子串相关
    contains(String str)
    indexof(String str)
    indexof(String str,int fromIndex);
    substring(int fromIndex)
    substring(int fromIndex,int endIndex);
    replace(string str1,string str2)
    split(String str); str作为分隔符,将字符串切割为String[]



P8-String习题课 25:58

1.判断一个字符串是否为 回文 字符串 abcdcba --》 abcdcba
2. 在一个字符串“ABCDIFGABC234BC23432BAC2343ABCD”中找出所有的“BC”字符串

private static boolean huiwen03() {
        String strInput="abcdefggfedcba";  //abcdcba   abcba  abba  都可以

        for(int i=0;i< strInput.length()/2; i++){
           if(strInput.charAt(i)!=strInput.charAt(strInput.length()-1-i)) return  false;
        }
        return true;
    }
  private static  void AllIndexOf(String s,String str){
        int start=0;
        while(true){
            int indexOf = s.indexOf(str, start);
            if(indexOf==-1) break;
            System.out.println(indexOf);
            start = indexOf + str.length();

        }
    }

P9-字符串常量池 1:04:48

串池,与 StringBuilder

一个String对象的内容是不可以改变的,因此多个引用可以指向同一个字符创对象。-----这句话体会一下串池的概念
当字符串的内容发生改变时候,只会创建新对象
虚拟机存储空间 :堆 栈 方法区
串池:字符串常量池 ,用来存放字符串对象,以供多个引用共享(通常存放在方法区)

Java基础提升高级API---百知教育java基础学习3
Java基础提升高级API---百知教育java基础学习3Java基础提升高级API---百知教育java基础学习3public interface CharSequence {
Java基础提升高级API---百知教育java基础学习3

package day14;

/**
 * @author leowei
 * @date 2020/12/29  - 15:27
 */
public class TestStringAppend {
    public static void main(String[] args) {
        String s1="ABC";
        String s2="ABC";
        System.out.println("s1 =  s2 :" +  s1== s2);            //false why???
        System.out.println("s1 =  s2 :" +  (s1== s2));            //true 
        System.out.println("s1.equals(s2) = " + s1.equals(s2));  //true 
        System.out.println("s2.equals(s1) = " + s2.equals(s1));  //true 

        String s3=new String("ABC");
        String s4=new String("ABC");
        System.out.println("s3==s4 = " + (s3 == s4));  //false 
    }
}

P10-集合的概念 48:30

集合: 用来存储对象的对象叫做集合-----容器 
object[]   数组,最基础的集合
数组是一种基础集合,数组存在如下弊端
1.数组长度固定,数组扩充是需要复杂的拷贝操作
2.数组元素在插入,删除时候不方便
         Object[] o={"ABC","DEF","XYZ"};  要插入LMN  到数组第一个位置
         Object[] o={"ABC","DEF","XYZ",null,null,null};  -- step1 扩容
         Object[] o={"ABC","DEF","XYZ","XYZ",null,null};  --- step2 挪动
         Object[] o={"ABC","DEF","DEF","XYZ",null,null};--- step3 挪动
         Object[] o={"ABC","ABC","DEF","XYZ",null,null};--- step4 挪动
         Object[] o={"LMN","ABC","DEF","XYZ",null,null}; --- step5 插入 



Java基础提升高级API---百知教育java基础学习3
// 自定义List 类

package day14.day15;

import java.util.Objects;

/**
 * @author leowei
 * @date 2020/12/29  - 16:18
 */
public class TestList {
    public static void main(String[] args) {

        MyList list = new MyList();
        list.add("zhangsan");
        list.add("lisi");
        list.add("wangwu");
        list.add("gousheng");    //大于三个自动扩容
        list.add("xiaoli");
        list.add(0,"huhu");

        for(int i=0;i<list.size();i++){
            Object o = list.get(i);
            System.out.println("o = " + o);
        }
        /*
        o = huhu     o = zhangsan   o = lisi
        o = wangwu   o = gousheng   o = xiaoli
        * */


    }
}

class  MyList{
    private Object[] os =new Object[3];
    private int index;  //数组中有效元素的个数,也是元素下标范围  0 -  index-1 ;

    //添加到元素末尾
    public void add(Object o){
       if(os.length==index){
           expand();
       }
       os[index]=o;
       index++;
    }

    //添加元素到指定pos下标
    public void add(int pos,Object o){
        if(os.length==index){
            expand();
        }
        for(int i=index;i>pos;i--){
            os[i]=os[i-1];
        }
        os[pos]=o;
        index++;

    }

    //数组扩容 2 倍
    public  void expand(){
        Object[] os2 = new Object[os.length * 2];
        for(int i=0;i<os.length;i++){
            os2[i]=os[i];
        }
        os=os2;
    }


    public int size(){
      return index;
    }

    public Object get(int pos){
        return os[pos];
    }
}

P11-List的常用方法 35:27

Java基础提升高级API---百知教育java基础学习3

collection 方法 说明
add(Object o) 把对象放入当前集合
AddAll(Collection c)
Clear() 清空集合
contains(Object o) 判断集合中是否存在o
remove(Object o) 00
size() 00
forEach() 遍历当前集合
toArray() 将当前集合转换为Object[]
-----list方法-------- ----------------
add(int pos,Object o) 将元素插入到当前集合的pos下标上
get(int pos )
indexOf(Object o)
remove(int pos) 删除集合中pos位置的元素
set(int pos,Object o) 将元素设置到当前集合的pos下标上
map 方法 说明
put(K key,V value) 把 key-value 键值对 放入map ,如果key 已经存在,新value覆盖老value
V get(K key)
containsKey(K key)
containsValue(V value)
size()
remove(K key)
keySet 返回所有键的集合
values 返回map中所有值的集合
集合的组成      java.util 包 
----collection----接口
      接口特点: 元素是对象(Objet)
      常用方法:(见上表 )
      遍历: 见下
      实现类: 无直接实现类
     
List   Collection 子接口
     接口特点:  元素有顺序,有下标 ,可以重复  
      常用方法:(见上表 )
      遍历: (四种) 迭代遍历  for-Each遍历  forEach()自遍历   下标遍历 
      实现类: ArrayList
Set    Collection 子接口
     接口特点:   元素无顺序,无下标 ,内容不可以重复  
      常用方法:(见上表 )
      遍历: (三种) 迭代遍历  for-Each遍历  forEach()自遍历 
      实现类: HashSet    LinkedHashSet    TreeSet  (自动对元素进行排序,根据规则过滤重复元素,极少用)

----map----接口
      接口特点: 元素是键值对    Key对象 无顺序,内容不可重复 ; value 对象 可以重复
      常用方法: 
      遍历: 见下
      实现类: HashMap  使用Hash算法实现(链表数组,红黑树)  1.2  线程不安全   允许Null作为key 或 value
              LinkedHashMap   HashMap的子类,维护键值对的添加顺序
              TreeMap  自动对键进行排序 
              HashTable     1.0 线程安全   慢   不允许Null作为key 或 value 
              Properties  Hashtable的子类 用于配置文件 
      简介:    英汉词典就是 map       apple --苹果    (apple 不可以重复)
               用户名密码  也是 map    username1 -- pwd1 (username不可以重复)

P12-List的四种遍历方式 1:13:15

package day14.day15;

import javax.lang.model.SourceVersion;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Objects;
import java.util.function.Consumer;

/**
 * @author leowei
 * @date 2020/12/29  - 16:18
 */
public class TestList {

    private static String result="";
    public static void main(String[] args) {

        //原始数据 
       // MyList list = new MyList();       // 自定义List类
        list.add("zhangsan");
        list.add("lisi");
        list.add("wangwu"

        //list  的四种遍历方式
        System.out.println("==============下标遍历==================");
        //方式一    下标遍历  (可以遍历List 不可以遍历Set ,因为set 没有下标 )
        for(int i=0;i<list.size();i++){
            Object o = list.get(i);
            System.out.println("  o = " + o);
        }

        //方式二 迭代方式遍历    自jdk1.2 方式出现的迭代方式
        System.out.println("===============迭代方式遍历=============");
        Iterator it = list.iterator();
        while(it.hasNext()){
            Object next = it.next();
            String s =(String) next;
            System.out.println("  s = " + s);
        }

        //方式三 for-Each   自jdk1.5 方式出现的迭代方式
         System.out.println("===========for-Each 遍历 ============");
        for(Object o: list){
            String s=(String)o;
            System.out.println("s = " + s);
        }

        //方式四 forEach 自遍历   自jdk 8 开始 (有如下三种变形)
         System.out.println("===========forEach 自遍历 1 接口回调 ============");
        class MyConsumer implements Consumer{
            @Override
            public void accept(Object o) {
                System.out.println(o);
            }
        }
        // 接口回调
        list.forEach(new MyConsumer());
        System.out.println("===========forEach 自遍历2  匿名内部类 ============");
        //方式4.1
        list.forEach(new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.println(o);
            }
        });

        System.out.println("===========forEach 自遍历 3 lambda ============");
        //方式4.2  lambda 把代码当做参数传递
        list.forEach(x-> System.out.println("x = " + x));

     
        // final String  result="";//result 外部类的局部变量
        // lambda 中不能改变 外部类的局部变量
        // lambda 访问外部类的局部变量的时候默认增加 final  ,final 限定不可以改值,所以要将result放到外部,作为成员变量,供lambda表达式访问
        System.out.println("===========番外:  forEach  使用成员变量  ============");
        list.forEach(x-> result+=x );
        System.out.println("result = " + result);
    }
}

P13-泛型 JDK 5 45:57

集合中存储的是对象,无法对元素的类型做出约定----类型不安全
List list = new ArrayList();
list.add(对象);
Object o =list.get(0);

String[]
Int[] --------------------数组是安全的,类型确定

JDK1.5 开始使用泛型 ,利用泛型,可以约定集合中元素的类型。

interface A{
   void  m1(String s);
   Interger m2();
}

// 1.5 以后
interface A<T> {
    void m1(T s);
}

class B implates A<String>{
    public void m1(String){}
}

// 1.5 以后
interface A<T,V> {
    void m1(T s);
    V m2();
}

class B implements A<String,Integer>{
    public void m1(String s){}
    public Integer m2{ return 0; }
}

class C implements A<Double,String>{
    public void m1(Double d){}
    public String m2{ return ""; }
}
// E 约束了集合中元素的类型  
interface List <E>{
   void add(E o);
   E get(int pos);
}

P14-List的实现类 33:44


不同的 list 实现类之间的区别是什么?
散列表:   分散排列  
ArrayList (线程不安全,高效)     数组实现     ---  查询快       增删慢     ----- JDK1.2 (1998)
LinkedList                     链表实现     ---  查询慢       增删快
Vector    (线程安全,低效)      数组实现                                ----- JDK1.0 (1995)
HashSet                        散列表       ---  查询块       增删快    

P15-Set集合 1:23:26

https://www.bilibili.com/video/BV1pE41137JY?p=15
看下图,散列表有很多的无效空间,散列表 查询也快,插入也快,是典型的用空间换时间的方式。
Java基础提升高级API---百知教育java基础学习3先看Hashcode ,hashcode 相同,再比较equals

Java基础提升高级API---百知教育java基础学习3

Set 无下标,无序,不可以重复
(三种) 迭代遍历 for-Each遍历 forEach()自遍历
HashSet 底层 还是数组 ,具体的叫法是 链表数组

如果将自定义的对象放入HashSet ,为了保证元素内容不重复
1.)覆盖hashCode方法,保证内容相同的对象返回相同的整数
2.)覆盖equals方法,保证内容相同的对象返回true
3.)尽量保证不同对象,返回不同hashcode


P16-Map集合 1:14:55

https://www.bilibili.com/video/BV1pE41137JY?p=16
Java基础提升高级API---百知教育java基础学习3

P17-集合习题课 1:01:16


P18-JDK5中的语法 44:22

1.静态引入

2. 可变长参数
    //a: 0-n个参数
    // 可变长参数相当于数组参数,int... a 相当于  int[] a
    // 一个函数的参数表中,只能有一个可边长参数,且必须是参数表的最后一个参数
    static void fn(int ... a){   //等同于  static void fn(int[] a){  }
        for (int i:a){
            System.out.println(i);
        }
    }
3 标注
    // 普通注释: 给人看的
    // 标注:     描述代码的代码  给机器看的
    // 标注使用场景:
    //           用在 包、类、属性、方法、构造函数等程序组件声明之前
    //@标注名(属性1=值1,... 属性n=值n);
    // 标记标注   没有属性   ()可以省略          @Override
    // 单值标注   只有一个属性 如果属性名为value ,value 可以省略 直接写 @标注名(值)
    // 普通标注   有属性
4. 格式化输出 printf 
    public static void main(String[] args) {
        String name ="llll";
        int age=40;
        // 格式化输出 
        System.out.printf("Student nam=%s,age=%d",name,age);   //printf 占位符
    }
5. 泛型
6. 自动封箱 装箱 
7. 枚举 

P19-异常的分类 1:08:31

Throwable/Exception/RuntimeException/ … 继承这个包的类,为检查异常,可以通过人工确认,避免异常发生的 。

  避免异常: 尽可能使异常不出现,不发生
  处理异常:  当异常发生时,应对这种情况   有部分代码,正常情况不执行,异常发生时候才执行 
  异常的分类
  Throwable  所有异常的父类
      Error      错误    严重的底层错误  不可避免   无法处理 
	  Exception  异常    可以处理的 
	       RuntimeException 子类   运行时异常  (编译器)未检查异常   可以避免  (可以处理,可以不处理,如人为的火灾 )
		   非RuntimeException 子类             (编译器)已检查异常   不可避免  (必须处理, 如地址 )
		   
		   if(a!=null)  a.method();   //避免  NullPointerException
		   if(i>=0 && i<a.lentgh)  System.out.println(a[i]); 避免ArrayIndexoutofBoundsException
		   if(a instanceof Dog)  Dog d =(Dog) a;     //避免  ClassCastException  
		   //查看以上几个EXCEPTION都是RuntimeException 的子类,都是可以避免的运行时异常  ,  
		          
  

Java基础提升高级API---百知教育java基础学习3
未检查异常
Java基础提升高级API---百知教育java基础学习3
已检查异常
Java基础提升高级API---百知教育java基础学习3Java基础提升高级API---百知教育java基础学习3
Java基础提升高级API---百知教育java基础学习3

P20-异常的产生和传递 23:56

P21-声明抛出异常 55:41

异常处理方式:
1. 声明抛出 : 此种方式只是转移了异常,并没有真正处理异常
public void method() throws IOException
throws 异常类名1 , 异常类名2 , 异常类名3
方法覆盖时,子类不能比父类抛出更多的异常
Java基础提升高级API---百知教育java基础学习3

2.  捕获异常

try{
语句1
语句2
语句…
语句n
}
catch(异常引用1 e){
}
catch(异常引用2 e){
}
catch(异常引用3 e){
}

Java基础提升高级API---百知教育java基础学习3

package day18;


import java.io.EOFException;
import java.io.FileNotFoundException;
import java.io.IOException;

/**
 * @author leowei
 * @date 2020/12/30  - 9:42
 * main      ---- 总理
 * mProvince  --- 省长
 * mCity     ---- 市长
 * mVillage  ---- 村长
 */
public class TestException {
    public static void main(String[] args) throws Throwable  {
        System.out.println("main 1 ------------------");
        mProvince(2);
        System.out.println("main 2 ------------------");
        System.out.println("main 3 ------------------");
    }

    // 省长
    static void mProvince(int i) throws Exception {
        System.out.println("ma 1  =========");
        mCity(i);
        System.out.println("ma 2  =========");
        System.out.println("ma 3  =========");
    }
    //市长
    static void mCity(int i) throws IOException,MyException{
        System.out.println("mb 1 ~~~~");
        mVillage(i);
        System.out.println("mb 2 ~~~~");
        System.out.println("mb 3 ~~~~");
    }

    //村长
    static void mVillage(int i) throws EOFException,FileNotFoundException,MyException {
        System.out.println("mc 1");
        if (i == 0) throw new NullPointerException("模拟空指针异常,夫妻吵架,村长处理");
        if (i == 1) throw new EOFException("EOF  文件以外终止,旱灾 村长不处理,报告县长");
        if (i == 2) throw new FileNotFoundException("文件没有找到,洪灾 村长不处理,报告县长");
        if (i == 3) throw new MyException("我自己定义的异常 ,遇到疫情 村长不处理,报告县长");
        System.out.println("mc 2");
        System.out.println("mc 3");
    }
}

//自定义异常类
class MyException extends Exception{
    public MyException(){}
    public MyException(String msg){
        super(msg);
    }
}


P22-捕获异常 1:05:23

try{} catch(){}
try{} catch(){} finally {}
try{} finally {}
Java基础提升高级API---百知教育java基础学习3

package day18;

/**
 * @author leowei
 * @date 2020/12/30  - 12:15
 */
public class TestFinally {
    public static void main(String[] args) {
        System.out.println(fn(2));   //结果 2    不管错还是对 都执行 finnally 的语句
        System.out.println("---------------------------------");
        System.out.println(fn(0));   //结果 2     不管错还是对 都执行 finnally 的语句
    }
    static int fn(int n){
        try {
            int a=6/n;
            return a;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        } finally {
            return 2;
        }
    }
}



P23-IO流的分类 43:34

Java程序的输入和输出
流对象(Stream): 用来传输数据的对象
流的分类:3中分类方式
方式1:按照流的方向
-------输入流:读数据
-------输出流 :写数据
方式2:数据单位
-------字节流:以字节为单位串数据, 可以处理一切数据
------- 字符流:以字符为单位串数据 , 专门用于处理文本数据(.txt .html .java .xml)

方式3: 流的功能
-------节点流:实际负责数据传输
-------过滤流:为节点流增强功能

Java基础提升高级API---百知教育java基础学习3
Java基础提升高级API---百知教育java基础学习3

P24-字节流-1 25:39

java.io.InputStream / OutputStream 是个抽象类 所有字节流的父类
*****InputStream,*****OutputStream ,父类作为子类的后缀
FileInputStream,FileOutputStream 文件字节流

在这里插入代码片

P25-字节流-2 34:57

标准处理FileOutoutStream流的方式

package day19;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

/**
 * @author leowei
 * @date 2020/12/30  - 14:45
 */
public class TestOutputStream2 {
    public static void main(String[] args) {
        OutputStream os=null;
        try {
            os =new FileOutputStream("a.txt");
            os.write('D');
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if(os!=null){
                    os.close();//关闭流 
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}


try-with-resource jdk 1.7 开始
try( 实现 AutoCloseable接口的 资源 ){}
catch(Exception e){}
//关闭资源 无需程序员关注了

  // 用下面的语句替换上面的语句 
       //放入 try 块的所有资源必须实现 AutoCloseable接口 
       try(OutputStream os=new FileOutputStream("a.txt")) {
           os.write('D');
       }catch(IOException e){
           e.printStackTrace();
       }
package day19;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 * @author leowei
 * @date 2020/12/30  - 15:02
 */
public class TestInputStream {
    public static void main(String[] args) throws Exception {
        m1();
        return;
    }

    // throw exception 的写法
    private static void m1() throws IOException {
        InputStream is = new FileInputStream("a.txt");
        //int read = is.read();   //从文件中读一个字节,返回值就是字节对应的数字 (A --> 65 )
        while (true){
            int a= is.read();
            if(a==-1){
                break;
            }
            System.out.println("a = " + a);
            System.out.println("change type a is " + (char)a);
        }
        is.close();
    }

    // try-with-resource   写法  (自 jdk 1.7 开始 )
    private static void m2() {
        try( InputStream inputStream = new FileInputStream("a.txt")){
            while (true){
                int a= inputStream.read();
                if(a ==-1){
                    break;
                }
                System.out.println("change type a is " + (char)a);
                System.out.println("a = " + a);
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

P26-缓冲字节流 1:16:22

BufferedInputStream / BufferedOutputStream 过滤流
缓冲功能,提高IO 效率

IO 编程基本顺序
1.创建节点流
2.封装过滤流
3.读写数据
4.关闭外层流

        FileOutputStream fos = new FileOutputStream("a.txt");
        BufferedOutputStream out = new BufferedOutputStream(fos);
        out.write('A');
        out.close(); 

Java基础提升高级API---百知教育java基础学习3

package day19;

import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * @author leowei
 * @date 2020/12/30  - 15:53
 */
public class TestBufferedStream {

    public static void main(String[] args) throws IOException {
       // m1();
        m2();
    }
    // 缓冲流 标准 写法
    private static void m1() throws IOException {
        FileOutputStream fos = new FileOutputStream("a.txt");
        BufferedOutputStream out = new BufferedOutputStream(fos);
        out.write('A');
        out.write('B');
        out.write('C');
        out.write('D');
        out.flush();        //清空缓冲区, 不关闭流
        //out.close();         //关闭 BufferedOutputStream 自动 关闭  其包装的  FileOutputStream
    }

    // 缓冲流 Jdk 1.7 后的   try-with-resource  写法
    private static void m2() {
        try (FileOutputStream fos = new FileOutputStream("a.txt");
             BufferedOutputStream out = new BufferedOutputStream(fos);
        ) {
            out.write('A');
            out.write('B');
            out.write('C');
            out.write('D');
            out.flush();        //清空缓冲区, 不关闭流
            //out.close();         //关闭 BufferedOutputStream 自动 关闭  其包装的  FileOutputStream
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

P27-对象序列化 40:25

ObjectOutputStream / ObjectInputStream 对象流
对象序列化: 把对象通过流来传输
只有实现了 java.io.serializable 这个接口,才能实现序列化
用transient修饰的属性成为临时属性,不参加序列化

Java基础提升高级API---百知教育java基础学习3Java基础提升高级API---百知教育java基础学习3

package day19;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * @author leowei
 * @date 2020/12/30  - 16:42
 */
public class TestObjectStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Employee e = new Employee("lichao", 44);
        FileOutputStream fos = new FileOutputStream("a.data");        // 1. 创建节点流
        ObjectOutputStream oos =new ObjectOutputStream(fos);                 // 2. 创建过滤流
        oos.writeObject(e);                                                  // 3. 写数据
        oos.close();                                                         // 4. 关闭节点
        System.out.println("ok");
        FileInputStream fis=new FileInputStream("a.data");
        ObjectInputStream ois =new ObjectInputStream(fis);
        Employee o = (Employee)ois.readObject();
        ois.close();
        System.out.println(o.getName()+"    ----    "+  o.getAge());
        // lichao    ----    0
        // transient int age;  age 使用transient 娶不到值 多以为空
    }
}


class Employee implements Serializable{
    String name;
    transient int age;
    //不想让属性参加序列化   -- Transient 临时属性,不参加序列化

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Employee(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

P28-对象的克隆 1:04:49

透彻的讲 浅拷贝 深拷贝
https://www.bilibili.com/video/BV1pE41137JY?p=28
克隆一个对象: equals 为 true , == 为 false
浅拷贝:需要克隆的类,必须实现Cloneable接口,super.clone() 利用Object类的Clone方法实现
深拷贝:无需实现Cloneable接口

浅拷贝

代码路径: day20.TestClone
https://github.com/wei198621/javaBasic03Apis/blob/main/src/main/java/day20/TestClone.java

Java基础提升高级API---百知教育java基础学习3

Java基础提升高级API---百知教育java基础学习3浅拷贝代码
浅拷贝: 对象在复制,但是对象内的属性没有复制

   //1. 覆盖object类的clone方法,将访问修饰符从Protected提高为public
    // 2. 需要克隆的类,必须实现Cloneable接口,
   public Object Clone(){
       try {
           return super.clone();
       } catch (CloneNotSupportedException e) {
           e.printStackTrace();
           return null;
       }
   }
package day20;

/**
 * @author leowei
 * @date 2020/12/30  - 17:45
 */
public class TestClone {
    public static void main(String[] args) {

        Teacher t = new Teacher("hxz", 44);
        Student s = new Student("weilie", 22,t);
        System.out.println("s = " + s);
        Student s2 =(Student)s.Clone();
        System.out.println("s2 = " + s2);   //Student implements  Cloneable{  正常clone

        System.out.println("s== s2 = " + (s == s2));  //  false 不是同一个对象
        System.out.println(s.getTeacher()==s2.getTeacher()) ;  //true
        //System.out.println(s.getName() == s2.getName());     //true


    }
}

class Student implements  Cloneable{
    private String name;
    private int age;
    private Teacher teacher;

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public Teacher getTeacher() {
        return teacher;
    }

    public Student(String name, int age, Teacher teacher) {
        this.name = name;
        this.age = age;
        this.teacher = teacher;
    }

    // 浅拷贝
    //1. 覆盖object类的clone方法,将访问修饰符从Protected提高为public
    // 2. 需要克隆的类,必须实现Cloneable接口,
   public Object Clone(){
       try {
           return super.clone();
       } catch (CloneNotSupportedException e) {
           e.printStackTrace();
           return null;
       }
   }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", teacher=" + teacher +
                '}';
    }
}

class Teacher{
    private String name;
    private int age;

    public Teacher(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

深拷贝

代码路径: day20.TestCloneDeep
https://github.com/wei198621/javaBasic03Apis/blob/main/src/main/java/day20/TestClone.java

Java基础提升高级API---百知教育java基础学习3

package day20;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * @author leowei
 * @date 2020/12/30  - 17:45
 */
public class TestCloneDeep {
    public static void main(String[] args) {

        Teacher2 t = new Teacher2("hxz", 44);
        Student2 s = new Student2("weilie", 22,t);
        System.out.println("s = " + s);
        //Student2 s2 =(Student2)s.Clone();
        Student2 s2 =(Student2)s.ClonePlus();
        System.out.println("s2 = " + s2);   //Student implements  Cloneable{  正常clone

        System.out.println("s== s2 = " + (s == s2));  //  false 不是同一个对象
        System.out.println(s.getTeacher()==s2.getTeacher()) ;  //false
        System.out.println(s.getName() == s2.getName());     //false

    }
}

class Student2 implements  Serializable{
    private String name;
    private int age;
    private Teacher2 teacher;

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public Teacher2 getTeacher() {
        return teacher;
    }

    public Student2(String name, int age, Teacher2 teacher) {
        this.name = name;
        this.age = age;
        this.teacher = teacher;
    }

    // 深拷贝
    //1. 当前对象要实现 implements  Cloneable ,Serializable 两个接口

   public Object Clone() {
        //将当前Student对象 放到a.data目录  a.data 在本地,涉及到 虚拟机向本地数据的存储
       try (FileOutputStream fos = new FileOutputStream("a.dat");
            ObjectOutputStream out = new ObjectOutputStream(fos);) {
           out.writeObject(this);
       } catch (Exception e) {
       }
       //将a.data目录数据取出  反序列化到Student对象
       try (FileInputStream fis = new FileInputStream("a.dat");
            ObjectInputStream in = new ObjectInputStream(fis);) {
           Object o = in.readObject();
           return o;
       } catch (Exception e) {
           return null;
       }
   }

    // 深拷贝
    //1. 当前对象要实现 implements  Cloneable ,Serializable 两个接口
    //ByteArrayInputStream   ByteArrayOutputStream

    public Object ClonePlus() {
        //将当前Student对象  byte[] bs  bs在虚拟机中,所以很快
        byte[] bs =null ;
        try ( ByteArrayOutputStream bos =new ByteArrayOutputStream();
             ObjectOutputStream out = new ObjectOutputStream(bos);) {
            out.writeObject(this);
            bs = bos.toByteArray();
        } catch (Exception e) {
        }
        //将byte[] bs   反序列化到Student对象
        try ( ByteArrayInputStream bis =new ByteArrayInputStream(bs);
             ObjectInputStream in = new ObjectInputStream(bis);) {
            Object o = in.readObject();
            return o;
        } catch (Exception e) {
            return null;
        }
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", teacher=" + teacher +
                '}';
    }
}

class Teacher2 implements Serializable{
    private String name;
    private int age;

    public Teacher2(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

P29-字符编码与乱码问题 1:12:26

P30-字符流 33:46

P31-File类 20:06

P32-IO习题课 42:45

P33-多线程的基本编程 1:01:23

P34-线程的基本状态 35:57

P35-线程的阻塞 22:40

P36-线程池 1:01:04

P37-Callable和Future接口 54:46

P38-多线程的同步 1:06:12

P39-同步代码块 58:42

P40-同步方法 11:13

P41-线程安全的集合 50:24

P42-队列接口 31:51

P43-死锁问题 28:59

P44-类对象 56:58

P45-反射的应用 1:08:47

P46-单例设计模式 55:02

P47-工厂设计模式 42:55

本文地址:https://blog.csdn.net/wei198621/article/details/111876706

相关标签: java 基础