Java基础学习

前言

这篇博客用于Java基础学习，每次更新笔记时需记录当前更新时间..

笔记区

数据类型拓展

整数拓展

   		//整数拓展(进制)
           int i= 10;//10进制
           int i2 = 010;//8进制
           int i3 = 0x10;//16进制
           int i4 = 0b10;//2进制
           System.out.println(i+" "+i2+" "+i3+" "+i4);//10 8 16 2

浮点数拓展
- float特点:有限离散舍入误差大约接近但不等于*
- 最好完全避免使用浮点数进行比较,见以下案例

   		float d1 = 138912478f;
   		float d2 = d1 + 1;
   		System.out.println(d1==d2);//打印结果为true,是不是很惊讶

*银行表示钱用什么？BigDemical数学工具类* **

字符拓展

所有的字符本质还是数字

编码:

Unicode|65=A,97=a|2字节|0-65536(2^16⁾

//字符拓展
char c1= '\u0061';//注意char类型要用'
System.out.println(c1);//a

Less is more 大道至简

//布尔拓展
boolean bool=true;
if(bool=true){};
if (bool){};//精简

类型转换

强制类型转换高->低
自动类型转换低->高

注意:

不能对布尔值进行转换
不能把对象类型转化为不相干的类型
高容量转换成低容量类型时,强转
强转时注意数据类型范围,超出低容量范围时会发生溢出,如下

int a = 128;
byte b = (byte)i;
System.out.println(b);//-128,因为发生了内存溢出

溢出问题

操作比较大的数时注意溢出问题

JDK7特性,数字之间可用下划线分割

//溢出问题
int money = 10_0000_0000;
int years = 20;
int total1 = money * years;//-1474836480,溢出
long total2 = (long)money * years;//不溢出
System.out.println(total1);

Javadoc

Javadoc 用来生成自己api文档

命令行生成

javadoc -encoding UTF-8 -charset UTF-8 Java文件名.java

在方法上使用文档注释标注参数信息

参数信息:

@author 作者名
@version 版本名
@since 指明最早需要使用的jdk版本
@param 参数名
@return 返回值情况
@throws 异常抛出情况

Idea生成

打开菜单->tools->generate Javadoc

2023-7-20 编辑所有内容至此

命令行传递参数

package com.monki.javabase;

public class CommandArg {
    public static void main(String[] args) {
        for (String arg:args){
            System.out.println(arg);
        }
    }
}

若当前Java文件有包名,直接在Java文件所在路径下用命令行执行会报错

正确执行方法:进入到src目录,在类名前加上包名,如图

可变参数

jdk1.5开始,JAVA支持传递同类型的可变参数给一个方法
在方法声明中,在指定参数类型后加…
一个方法只能指定一个可变参数,它必须是方法的最后一个参数,任何普通参数需在其前面声明
可变参数的本质是数组

package com.monki.javabase;

public class VariableArg {
    public static void main(String[] args) {
        new VariableArg().printMyArg("下面是我的可变长参数",4536251,1433223);
    }
    public void printMyArg(String s,int... i){
        System.out.println(s);
        for (int x:i){
            System.out.println(x);
        }
    }
}

数组内存分析

graph LR;
	Java内存-->堆;
		堆-->存放new出来的对象和数组;
		堆-->可以被所有的线程共享,不会存放别的对象引用
	Java内存-->栈;
		栈-->存放基本变量类型,会包含这个基本类型的具体数值
		栈-->引用对象的变量,会存放这个引用在堆里面的具体地址
	Java内存-->方法区;
		方法区-->可以被所有的线程共享
		方法区--> 包含了所有类和static变量

创建分析

接口

只有规范!无法写自己的方法~专业的约束! 约束和实现分离:面向接口编程~

接口的本质是契约

作用:

约束
定义一些方法,让不同的人实现
方法 public abstract
变量 public static final
接口不能被实例化,因为接口中没有构造方法
implement可以实现接口
必须要重写接口中的方法

package com.monki.javabase;
//锻炼抽象的思维,能通过接口定义一个系统时,你的架构能力就很强了
//interface定义的关键字,接口都需要有实现类
public interface InterfaceStudy {
    //常量 public static final
    int AGE=99;
    //接口中所有定义的方法都是抽象的(默认:public abstract)
   void run(String name);
   void delete(String name);
   void update(String name);
   void query(String name);
}

package com.monki.javabase;

public interface TimeService {
    void timer(); 
}

package com.monki.javabase;

//类 可以通过implements实现接口
//实现了接口的类,必须重写接口中的方法
//利用接口实现多继承
public class InterfaceStudyImpl implements InterfaceStudy,TimeService{

    @Override
    public void run(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

2023-7-25 编辑所有内容至此

抽象类

抽象类中可以没有抽象方法,但有抽象方法的类一定要声明为抽象类
抽象类不能用new关键字来创建对象,它是用来让子类实现的
抽象方法只有方法的声明,没有方法的实现,它是用来让子类实现的
子类继承抽象类,那么就必须实现抽象类没有实现的抽象方法,否则该子类也要声明为抽象类

package com.monki.javabase;

//abstract 抽象类: 类 extends:单继承~ 接口用来多继承
public abstract class ActionAbstract {

    //存在默认构造方法,供子类构造器执行父类构造
    public ActionAbstract(){
        
    }
    //约束~有人帮我们实现
    //abstract方法:只有方法的名字,没有方法的实现
    public abstract void doSomething();

    //1.不能new抽象类的实例,只能靠子类来实现它约束~
    //2.抽象类中可以写普通的方法
    //3.抽象方法必须在抽象类中
    //抽象的抽象:约束~
    
    
}

package com.monki.javabase;

//抽象类的所有方法,继承了它的子类,都必须要实现它的方法,除非继承它的类也声明为抽象类,抛给继承他的类的子类来实现
public class A extends ActionAbstract{

    @Override
    public void doSomething() {

    }
}

内部类

成员内部类
静态内部类
局部内部类
匿名内部类

package com.monki.javabase;

public class OuterClass {
    private int id=10;
    private static int sid =6;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    //成员内部类
    public class InnerMemberClass{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //获得外部类的私有属性
        public void getID(){
            System.out.println(id);
        }
        public void getSid(){
            System.out.println(sid);
        }
    }
    //静态内部类
    public static class InnerStaticClass{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //无法访问外部类的非静态私有属性id
        public void getSid(){
            System.out.println(sid);
        }

    }
    //局部内部类,写在方法里
    public void method(){
        class InnerAreaClass{
            public void in(){

            }
        }
    }

    public static void main(String[] args) {
        //匿名内部类,是UserService这个接口的实现类,需要重写接口里的方法
        //可以返回一个对象,但是这个类没有名字

        UserService userService = new UserService() {

            @Override
            public void hello() {
                System.out.println("通过匿名内部类的对象调用此方法");
            }
        };
        userService.hello();
    }

}
interface UserService{
     void hello();
}

package com.monki.javabase;

public class InnerClassTest {
    public static void main(String[] args) {
        //创建外部类
        OuterClass outer = new OuterClass();
        //通过外部类实例化成员内部类
        OuterClass.InnerMemberClass innerMem = outer.new InnerMemberClass();

        //通过外部类.静态内部类实例化静态内部类
        OuterClass.InnerStaticClass innerStatic = new OuterClass.InnerStaticClass();




        //成员内部类获取外部类私有属性
        innerMem.getID();
        innerMem.getSid();
        //静态内部类获取外部类私有静态属性
        innerStatic.getSid();


    }
}

Error和Exception

简单分类：

检查性异常：可能由用户引起，程序员无法预见，在编译时不能简单被忽略
运行时异常：可能被程序员避免的异常，可以在编译时被忽略
错误ERROR:与JVM相关

Error:

Error对象由Java虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关

Exception:

一般由程序逻辑错误引起，程序员应该从逻辑角度尽可能避免这些异常

捕获和抛出异常

异常处理五个关键字
- try,catch,finally,throw,throws

package com.monki.javaException;

public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;

        new Test().test(a,b);

       /* //假设要捕获多个异常：要从小到大
        try{//try监控区域
            if(b==0){//主动抛出异常 throw
                throw new ArithmeticException();
            }
            //System.out.println(a/b);
            //new Test().a();
        }catch(Error e){//catch(想要捕获的异常类型)
            //catch 捕获异常
            System.out.println("Error");
        }catch (Exception e){
            System.out.println("Exception");
        }catch (Throwable t){
            System.out.println("Throwable");
        }finally {//处理善后工作
            System.out.println("finally");
        }*/
        //finally可以不要，一般用于IO等资源关闭

    }
    //假设这个方法中，处理不了这个异常。方法上抛出异常
    public void test(int a,int b) throws ArithmeticException{
        if (b==0) {
            throw new ArithmeticException();//主动抛出异常，一般在方法中使用
        }
        System.out.println(a/b);
    }

    public void a(){b();}
    public void b(){a();}

}

自定义异常

用户自定义异常类，只需继承Exception类即可

package com.monki.javaException;

//自定义异常类
public class MonkiException extends Exception{

    //传递数字>10
    private int detail;

    public MonkiException(int a) {

        super("123");//没有toString方法才会执行
        this.detail = a;
    }

    @Override
    public String toString() {
        return "MonkiException{" +
                "detail=" + detail +
                '}';
    }
}

心得区

音乐分享

上篇梦开始的地方

下篇Linux&termux使用相关