javaSe基础篇

最新推荐文章于 2024-11-01 14:48:20 发布
最新推荐文章于 2024-11-01 14:48:20 发布
阅读量198 收藏
点赞数
分类专栏： 自学JAVA70天 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45454303/article/details/119740784
版权

javaSe基础篇

JDK的下载和安装

官方网址

在这里插入图片描述

1.按照提示安装即可

2.配置环境变量

新建JAVA_HOME:

 

配置系统path路径(也可以设置用户path,但是当系统和用户变量同时存在是,会优先选择系统环境变量)

 

3.环境变量配置完成，检查是否配置正确，启动命令窗口：

win+R：cmd

  • 输入java、javac、java -version：

在这里插入图片描述在这里插入图片描述在这里插入图片描述

DOS命令概述

1.打开DOS窗口:win+R

2.查看当前目录所有文件:dir\

 

3.切换盘符:cd /d A:

 

4.清除屏幕：cls

在这里插入图片描述

5.查看本机IP:ipconfig

 

6.相关文件的操作：

  • md 创建文件夹

  • rd 移除文件夹

  • cd>a.txt 新建文件

  • del a.txt 删除文件

基础语法

注释

1.单行注释://

2.多行注释:/* */

3.文档注释:/** */

关键字

关键字是java里有特殊意义的标识符

如for,if,case

数据类型

1.java是强类型语言

所有变量要先定义(变量名,类型,作用域,变量值)

2.java的数据类型分为两大类

1.基本数据类型

简单类型booleanbytecharshortIntlongfloatdoublevoid
二进制位数18161632643264--
封装器类BooleanByteCharacterShortIntegerLongFloatDoubleVoid

byte：8位，最大存储数据量是255，存放的数据范围是-128~127之间。

short：16位，最大数据存储量是65536，数据范围是-32768~32767之间。

int：32位，最大数据存储容量是2的32次方减1，数据范围是负的2的31次方到正的2的31次方减1。

long：64位，最大数据存储容量是2的64次方减1，数据范围为负的2的63次方到正的2的63次方减1。

float：32位，数据范围在3.4e-45~1.4e38，直接赋值时必须在数字后加上f或F。

double：64位，数据范围在4.9e-324~1.8e308，赋值时可以加d或D也可以不加。

boolean：只有true和false两个取值。

char：16位，存储Unicode码，用单引号赋值。

2.引用数据类型(变量,对象)

3、常见的问题

  1. 银行业务的表示：

    不能使用浮点数，会有舍入误差，只能说接近，因为会有精度损失

  2. BigDecimal：数学工具类；

变量 常量

public class Test01 {
    public static void main(String[] args) {
        //局部变量
        int a=100;
        //常量
        final int MAX_A=100;
        Test01 test01 = new Test01();
        System.out.println(test01.id);
        System.out.println(b);
        System.out.println(MAX_A);
        System.out.println(PI);
        System.out.println(a);
    }
    //实例变量
    int id;
    String name;
    int age;
    //类变量
    static int b;
    static final double PI=3.14;
public class Demo3 {
        int a;
        String b;
        boolean c;
        public static void main(String[] args)
        {
            Demo3 test = new Demo3();
            int a=test.a;
            System.out.println(a);//实例变量在创建实例时会被类加载器初始化,所以可以输出;
            System.out.println(test.b);
            System.out.println(test.c);
        }
}

类型转换

1.java中整数类型默认的int类型；小数类型默认的double；

2.String的字符串转化为char类型时，只能用char类型的数组来接收；字符串在转化成char类型是不能像int、float那样使用封装类的parseXXX方法等，但它可以转换成char类型的数组；long str1=Long.parseLong(str);

3.byte de=(byte) 128;System.out.println(de); 结果：-128 //如果数字溢出当前的数字类型，有两种方法可以阻止其出错，一种是直接强转成 当前数据类型，另一种是转成其他的数据类型（较大的）**

4.String的字符串进行类型转换时，如果字符串中包含long整形的字符大写L或者小写l时，在转换成字符串时，会出现错误

例如： String str="123L"; long str1=Long.parseLong(str); System.out.println(str1);//结果：错误

String的字符串是float、double浮点型时，字符串可以加f、F、D、d等，在进行基本类型转换时不会出错

例如： String f1="12.34f";

          float f2=Float.parseFloat(f1); 
​
          System.out.println(f2);//结果：12.34,；d、D也一样

5.自动类型转换(也叫隐式类型转换) ，其实就是小范围的数据类型向大范围的数据类型转换，例如int类型转long

强制类型转换(也叫显式类型转换) int b = (int)(i + j);

强制类型转换在某种情况下会丢失精度

表达式的数据类型自动提升

public class Demo1 {
    public static void main(String[] args) {
    int a =2;
    int b=3;
    double c=3.1415D;
    float d=3.141f;
    long e=352L;
    short f=12;
    char g='a';
    int a1=a++;
    int a2=++a;
    double h= Math.pow(2,3);
​
        System.out.println(g+f);
        System.out.println(a+b);
        System.out.println(a+b+c+d+e+f+g);//向上转型,类型自动提升为最大的
        System.out.println(a/b);
        System.out.println(a!=b);
        System.out.println(a1);
        System.out.println(a2);
        System.out.println(h);
​
    }
}

运算符

算数运算符的种类

+-*/%++--

注：整数相除只能得到整数，如果想得到小数，就要使用浮点数（float、double）；/是获得除法的商；%获取的是除法操作的余数（4%5=8），运算结果的符号取决于参与运算的左边的符号。

++--运算符的用法

++：自加。对原有的数据进行+1--：自减。对原有数据进行-1
放在操作数的前面和后面效果一样
注：放在操作数的前面，先自增或者自减，然后再参与运算; 放在操作数的后面，先参与运算，再自增或者自减。

Math类

double h= Math.pow(2,3);//2^3,因为java没有幂运算,除此之外还可以移位实现

赋值运算符的种类

=+=-=*=/=%=

赋值运算符的注意事项

基本的赋值运算符=：把=右边的数据赋值给左边。
扩展的赋值运算符+=,-=,*=,/=,%=：把左边和右边做加法，然后赋值给左边。
赋值运算符要求左边的数据必须是一个变量

关系运算符的种类

==!=<=>=><instanceof

关系运算符的注意事项

无论你的操作是简单还是复杂，结果是boolean类型
"=="不能写成"="

逻辑运算符的种类

！(非)&(与)&&(短路与)|(或)||(短路或)^(异或)
public class Demo2 {
    public static void main(String[] args) {
        int c=4;
        boolean d=(c<3)&&(c++<3);
        System.out.println(d);//短路
       
​
    }
}
​

位运算符的种类

~(按位取反)<<(左移)&(与)|(或)>>(右移)^(异或)>>>(无符号右移)
~:按位取反 0变1 1变0空位补0，被移除的高位丢弃&:有0则0^:相同则0，不同则1被移位的二进制最高位是0，右移后，空缺位补0；最高位是1，高位补1。^:相同则0，不同则1被移位二进制最高位无论是0或者是1，空缺位都用0补。

小知识:

System.out.println(2<<3);//表示2^3

三目运算符与格式

public class Demo2 {
    public static void main(String[] args) {
      
        String f=2<1?"good":"false";//前为真则为good,为假则为false;
        System.out.println(f);

    }

扩展运算符

+= -= *+ /= <<=

例:a+=c 等价于a=a+c a<<=x等价于a=a<<x

此处不做过多赘述

包机制:import package;

流程控制

用户交互Scanner

import java.util.Scanner;

Scanner s=new Scanner(System.in);

next() nextLine()获取输入内容

hasNext() hasNextLine()判断是否还有输入

package JavaSe.struct;

import java.util.Scanner;

public class ScannerDemo {
    public static void main(String[] args) {
        Scanner src=new Scanner(System.in);
        int[] i=new int[src.nextInt()];
        for (int x:i) {
            System.out.println(x);

        }
        src.close();
    }

}

顺序结构

顺序结构：就是从头到尾依次执行每条语句的操作。

选择结构

在java中，选择结构分为if-else语句和 switch 语句。

//单选择结构
if(布尔表达式){
    语句或语句块
}else{
    语句或语句块
}

//多选择结构
if(布尔表达式){
    语句或语句块
}else if(布尔表达式){
    语句或语句块
}else{
    语句或语句块
}

1）if括号里表达式的值返回的必须是布尔类型

2）如果条件体内只有一条语句需要执行，那么if后面的大括号可以省略。建议不要省略！

3）如果出现有多个if一个else的情况，else子句归属于最内层的if语句。

switch(表达式){
case 常量值1:
    语句块;
    break;
case 常量值2:
    语句块;
    break;
case 常量值3:
    语句块;
    break;
        ..
default:
    语句块;
    break;
}

1）switch中表达式的返回值只能是int，byte，char，short，枚举，字符串；

2）case子句中的值必须是常量，且不能重复；

3）default可有可无;

4）break作为某一个case代码段的结束句，使其跳出程序。

循环结构

while循环 do...while循环 for循环

public class BreakList {
    public static void main(String[] args) {
        int i=0;
        while(i<10)
        {
            if (i<5) {
                System.out.println(i);
            }
            i++;
            System.out.println(i);
        }
    }
}
public class Demo4 {
    public static void main(String[] args) {
        for(int j=1;j<10;j++)
        {
            for(int i=1;i<=j;i++){
                System.out.print(j+"*"+i+"="+j*i);
            }
            System.out.println();
        }

    }
}
public void test(){
        int i=0;
        do {
            if (i<5) {
                System.out.println(i);
            }
            i++;
            System.out.println(i);
        }
        while (i<10);
//for循环深入
//奇数和偶数的和分别是多少-100以内
public void test2(){
        int oddSum=0;
        int evenSum=0;
        for (int i = 0; i <= 100; i++) {
            if (i/2!=0){//奇数
                evenSum=evenSum+i;
            }else {//偶数
                oddSum=oddSum+i;
            }

        }
//九九乘法表
public void test3(){
    for(int i=0;i<10;i++){
        for(int j=0;j<10;j++){
            System.out.print(i*j);
        }
        System.out.println("");
    }
}
//增强for循环
//遍历数组
public void test4(){
    int[] arry=new int[10];
    for(int x;arry){
        System.out.printl(x);
    }
}

break && continue&&return

break语句：

break语句刚刚在switch中已经见过了，是用来终止case的。实际上，break出现在while，do-while，for循环中，用于强行退出当前循环。

continue语句：

continue只能用于for，while，do-while循环语句中，用于让程序跳出本次循环，直接进入下次循环。

return语句

public void show(){
        System.out.println("show---");
        return;//结束方法
    }
	public static int add(int a, int b){
        return a+b;//返回值
    }

三角形打印

public class Triangle {
    public static void main(String[] args) {
        for (int i = 0; i <=5; i++) {
            for (int j = 5; j >=i; j--) {
                System.out.print(" ");
            }
            for(int j=0;j<=i;j++)
            {
                System.out.print("*");
            }
            for(int j=0 ;j<i;j++)
            {
                System.out.print("*");
            }
            System.out.println();

        }
    }
}

###

方法

方法的定义和调用

  1. [修饰符] 返回值类型 方法名（[参数类型 参数名]，[…]）{return 值}

方法的重载

  1. 方法名必须相同

  2. 参数列表必须不同（个数不同、参数类型不同、参数列表的顺序不同）

  3. 参数的返回值类型可以不同也可以相同

  4. 仅仅返回值类不同不足以构成方法的重载

public static void main(String[] args) {
        test(3,5);//调用静态方法
        Test03 test03 = new Test03();
        System.out.println(test03.test(1,2,3));//调用非静态方法
        System.out.println(test03.test(1.0,2.0));
    }
    static void test(int a, int b){
        System.out.println(a+b);
        }
    int test(int a,int b,int c){
        return a+b+c;
    }
    double test(double a,double b){
        return a+b;
    }
}

可变参数

1.在方法声明中 类型后面加...

2.必须在参数列表的最后

3.储存类似于数组

int test(int... a){
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+"\t");
        }
        return 0;
    }
test03.test(1,2,3,4,5);//方法的调用

递归详解

  • 递归就是方法自己调用自己

  • 递归分为递归头 和 递归体

public class Demo1 {
    public static void main(String[] args) {
        System.out.println(f(3));
    }
    private static int f(int n){
        if (n==1){
            return 1;
        }else {
            return n*f(n-1);//10*9*8*7*6*5*4*3*2*1
        }
    }
}

数组

数组创建与声明

dateTyepe[] arrayNmae;或者dateTyepe[] arrayName[]

创建数组:dateType[] arrayName=new dateType[arraySize];或者 dateType[] arrayName={...};

数组一旦被创建,其大小不会改变

获取数组长度

arrays.length

内存分析

堆:存放对象及数组

栈:存放变量类型及引用对象的变量

方法区:calss static变量

二维数组

dateType arratName=new dateType[arraySize] [arraySize];或者 dateType[] arrayName={...};

冒泡排序

public class ArraysDemo2 {
    public static void main(String[] args) {
        int[] array={101,5,2,1,6,7,4,9,100,99};
        System.out.println(Arrays.toString(sort(array)));

    }
    public static int[] sort(int[] array){
        int imp=0;
        for (int i = 0; i <array.length-1; i++) {   		//每轮外层比较,内层两两比较,都会把最小或最大的冒泡到最后一位
            for (int j=0;j<array.length-1-i;j++){			//,因此,每轮外层之后都可以减少一个内层最后一位
                if (array[j+1]>array[j]) {
                    imp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=imp;
                }

            }

        }
        return array;
    }
}

稀疏数组

行数列数非0总数
xysum
非0元素.非0元素.非0元素.

public class ArraysDemo3 {
    ArraysDemo3(){
        System.out.println("调试");
    }
    public static void main(String[] args) {
        //创建原数组
        ArraysDemo3 test=new ArraysDemo3();
        int[][] array1 = new int[10][10];
        array1[2][5] = 25;
        array1[8][7] = 26;
        array1[9][9] = 88;
        //遍历输出原数组
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");

            }
            System.out.println("");

        }
        System.out.println("==========");
        //获取非0数组元素个数
        int sum = 0;
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                if (array1[i][j] != 0) {
                    sum++;
                }

            }

        }
        //根据非0元素个数觉得稀疏数组size;
        int[][] array2 = new int[sum+1][3];
        //稀疏数组头部
        array2[0][0] = 10;
        array2[0][1] = 10;
        array2[0][2]=sum;
        int sum2 = 1;
        //将原数组非0元素赋值稀疏数组
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                if (array1[i][j] != 0) {
                    array2[sum2][0] = i;
                    array2[sum2][1] = j;
                    array2[sum2][2] = array1[i][j];
                    sum2++;
                }
            }
        }
        for (int[] anInt2:array2)
        {
            for (int anInt3:anInt2)
            {
                System.out.print(anInt3+"\t");
            }
            System.out.println("");

        }
        System.out.println("======");
        //方向逆转稀疏数组
        System.out.println("还原");
        int[][] array3=new int[array2[0][0]][array2[0][1]];
        for (int i = 1; i <array2.length; i++) {
            for (int j = 0; j <array2[i].length; j++) {
                array3[array2[i][0]][array2[i][1]]=array2[i][2];

            }

        }
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");

            }
            System.out.println("");

        }
    }

面向对象

一切皆对象

类构造器

  1. 方法名和类名相同；

  2. 无参构造器是默认存在的；

  3. 如果自己定义了一个有参构造器，那么无参构造器必须显示定义

public class Student {
    String name;
    int age;
    //alt+insert自动生成
    //无参构造器
    public Student() {
    }

    //有参构造器
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    void study(){
        System.out.println(this.name+"\t"+this.age+"\t"+"在学习！");
    }
}


public class Application {
    public static void main(String[] args) {
        Student student1 = new Student("lscong",22);
        student1.study();
    }
}

封装

  1. 程序追求“高内聚、低耦合”，

  2. 高内聚：类的内部数据操作细节自己完成，不允许外部干涉；

  3. 低耦合：尽量暴露少量的方法给外部使用；

  4. 私有属性----定义set、get方法

一句话,属性私有(get/set方法)!

继承

  1. 关键字：extends；

  2. java中只有单继承，没有多继承；

  3. 子类拥有父类所有的东西，但是私有的东西是不能被继承的；

  4. Object是所有类的父类，直接继承Object

  5. super关键字：调用父类的属性及方法

  6. 重写：

    需要有继承关系，子类重写父类 方法名必须相同，方法体不同 参数列表必须相同 修饰符可以扩大：public>protected>default>private 抛出的异常：可以缩小，但是不能扩大 子类重写了父类，那么对象调用的就是执行重写的方法 为什么重写：

    父类的功能，子类不一定需要，或者不一定能够满足

  7. 1.父类是有参构造,子类必须调用父类的有参构造
2.子类加载构造器时,默认先加载父类构造器,以此类推到从父类的父类开始
3.调用父类或者自身构造器时,必须放在构造器方法的第一行
4.构造器可以有多个过载构造器(不同形参)

public class Teacher extends Person{

    Teacher(){
        super("name");//如果父类是有参构造,子类必须显示调用有参构造,因为子类默认构造无参构造

    }

public class Person {
    Person(){
        System.out.println("this is the father");
    }
    private String name;
    private String sex;
    private int age;
    public String str="这是父类常量";

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

    public void setSex(String sex) {
        this.sex = sex;
    }

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

    public String getName() {
        return name;
    }

    public String getSex() {
        return sex;
    }

    public int getAge() {
        return age;
    }
    public void test(){
        System.out.println("这是父类方法");
    }
    public static void test3(){
        System.out.println("这是父类静态方法");
    }
}
class Teacher extends Person{

    Teacher(){

    }
    public String str="这是子类常量";
    public void test(){
        System.out.println("这是子类方法");
    }
    public void test2(){
        System.out.println("这是子类多余方法");
    }
    public static void test3(){
        System.out.println("这是子类静态方法");
    }

    public static void main(String[] args) {
        Object teach=new Teacher();
        teach.test();
        teach.test3();
        System.out.println(teach.str);
        
        System.out.println(teach instanceof Person);
    }
}

多态

（Father f1=new Son（）；）

1.一个对象的实际类型是确定的,但指向它的引用可以不同

2.因为指向它的引用类型不同,而表现出不同的方法(因为编译时类型表现为父类,而运行时类型是子类)

3.多态的存在条件 有继承关系 子类重写父类的方法 父类的引用类型指向对象

4.只有方法多态,而无属性多态

6.总是执行子类的重写方法,而无法执行子类的独有方法

5.instanceof用于判断两个对象之间是否存在父子关系

    public static void main(String[] args) {
        Person teach=new Teacher();
        teach.test();//表现为子类重写方法
        teach.test3();//表现为子类重写方法
        //teach.test2();    //无法执行子类自有方法
        System.out.println(teach.str);

        System.out.println(teach instanceof Person);//ture
    }
}
Student s1=new Student();

Person s2=new Student();

Object s3=new Student();

//Object>Person>Student
//Object>Person>Teacher
//Object>String
s3 instanceof Student//true
s3 instanceof Person//true
s3 instanceof Object//true
s3 instanceof String//false
s3 instanceof Teacher//false
    
s1 instanceof Student//true
s1 instanceof Person//true
s1 instanceof Object//true
s1 instanceof String//编译错误
s1 instanceof Teacher//编译错误
    
s2 instanceof Student//true
s2 instanceof Person//true
s2 instanceof Object//true
s2 instanceof String//编译错误
s2 instanceof Teacher//false

static关键字

static修饰的方法或者是变量 常量 内部类都会变成类的成员变量,作为类的一部分

抽象类

  1. abstract关键字修饰

  2. 是一种约束，抽象方法，只有方法没有具体的方法体实现

  3. 只能靠子类去实现方法

  4. 抽象类中可以存在非抽象类方法，但是非抽象类不能写抽象方法

  5. 子类继承抽象类，必须对其抽象方法进行重写

public abstract class Abstract {
    Abstract(){
        System.out.println("抽象类里有构造器");
    }
    public abstract void doSomething();//抽象方法不能有方法体
    public void okk(){
        System.out.println("抽象类可以有普通方法");//抽象类可以有普通方法
    }
    //抽象方法必须在抽象类中
    //抽象类不能实例化
    //抽象类有构造器
    //抽象方法必须被子类实现
    //抽象类可以没有抽象方法

}
class Action extends Abstract{
    public void doSomething(){
        System.out.println("子类必须实现抽象方法");
    }

    public static void main(String[] args) {
        Action action=new Action();
        action.doSomething();;
        action.okk();
    }


}

接口

接口只有规范

1.implements：继承关键字

2.interface：修饰符

3.[public abstract] void run();//方法

4.接口中定义的变量均为常量：[public abstract final ] AGE=100；//接口里不允许有变量

5.接口可以实现多继承

6.只有规范，自己无法写方法

7.以后均在面向接口编程

8.子类继承接口，子类必须对其方法进行重写

public interface TimeType {
    int a=1;
    public static final int b=2;//接口里面的常量默认全部用public static final修饰
    void add();
    public abstract void delete();//接口里的方法全部默认用public abstract
}

内部类

成员内部类

public class Outer{
    private String name;
    private int age;
    public void outer(){
     	System.out.println("outer!");   
    }
 		public class Inner{
            public void inner(){
             	   System.out.println("inner!");   
            }
        }
}

//new
Outer outer=new Outer();//非静态内部类依赖于外部类实例而实例化
Outer.Inner inner=outer.new Inner();//非静态内部类创建实例语法 outerclassDemo.new.innerclass()
inner.inner();

静态内部类

public class StaticInner {

        private String name;
        private int age;
        public void outer(){
            System.out.println("outer!");
        }
        public static class Inner{
            public void inner(){
                System.out.println("inner!");
            }
        }

    public static void main(String[] args) {
        Inner test2=new Inner();//静态内部类不需要依赖外部类实例实例化

    }

}
class Normal{
    public static void main(String[] args) {
        StaticInner.Inner test3=new StaticInner.Inner();//静态内部类创建语法 new outerclass.innerclass()
    }

package JavaSe.oop;

public class Outer {
    static String name="外部类静态变量";
    String name2="外部类实例变量";
    String box="这是外部类重名变量";
    public static void test1(){
        System.out.println("这是外部静态方法");
    }
    public void test2(){
        System.out.println("这是外部实例方法");
    }
    public class Inner{
        Inner(){
            System.out.println("这是内部类的构造器");
        }
        static String innerName="这是内部类静态变量";
        String getInnerName2="这是内部类实例变量";
        String box="这是内部类重名变量";
        public static void innerTest(){
            test1();
            //test2(); //实例内部类静态方法无法访问实例外部类实例方法,即 静态无法访问实例
            System.out.println(name);
        }
        public void innerTest2() throws Exception{
            String box="这是方法局部变量";
            test1();
            test2();
            System.out.println(name2);
            System.out.println(box);
            System.out.println(this.box);
            System.out.println(Outer.this.box);
        }
    }

    public static void main(String[] args) {
        Outer outter=new Outer();
        Outer.Inner inner=outter.new Inner();  //内部类只能通过外部实例化类来实例化
        Outer.Inner.innerTest();
        //Outer.Inner.innerTest2();  //外部类实例化对象无法直接访问内部类实例方法;
        try {
            inner.innerTest2();
        }catch (Exception e){
            System.out.println(e);
        }
        inner.innerTest();

    }
}

非静态内部类依赖于外部类实例而实例化

静态内部类不需要依赖外部类实例实例化\

非静态内部类创建实例语法 outerclassDemo.new.innerclass()

静态内部类创建语法 new outerclass.innerclass()

实例内部类静态方法无法访问实例外部类实例方法,即 静态无法访问实例

局部内部类

public class Outer{
    private String name;
    private int age;
    public void outer(){
        public class Inner{
            private int score;
            void run(){
             	   System.out.println("run!");  
            }
        }
     	System.out.println("outer!");   
    }
}

匿名内部类

package JavaSe.oop;

public interface TimeType {
    int a=1;
    public static final int b=2;//接口里面的常量默认全部用public static final修饰
    void add();
    public abstract void delete();//接口里的方法全部默认用public abstract
}
class Test{
    public static void main(String[] args) {
        new TimeType(){				//在main方法里的匿名内部类
            @Override
            public void delete() {

            }

            @Override
            public void add() {
                
            }
        };
    }
}

异常处理

img

程序错误分为三种：1.编译错误；2.运行时错误；3.逻辑错误。 （1）编译错误是因为程序没有遵循语法规则，编译程序能够自己发现并且提示我们错误的原因和位置，这个也是大家在刚接触编程语言最常遇到的问题。 （2）运行时错误是因为程序在执行时，运行环境发现了不能执行的操作。 （3）逻辑错误是因为程序没有按照预期的逻辑顺序执行。异常也就是指程序运行时发生错误，而异常处理就是对这些错误进行处理和控制。

Throwable： 有两个重要的子类：Exception（异常）和 Error（错误），二者都是 Java 异常处理的重要子类，各自都包含大量子类。异常和错误的区别是：异常能被程序本身可以处理，错误是无法处理。

Thrwoable常用方法

1. 返回异常发生时的详细信息
public string getMessage();
 
2. 返回异常发生时的简要描述
public string toString();
 
3. 返回异常对象的本地化信息。使用Throwable的子类覆盖这个方法，可以声称本地化信息。如果子类没有覆盖该方法，则该方法返回的信息与getMessage（）返回的结果相同
public string getLocalizedMessage();
 
4. 在控制台上打印Throwable对象封装的异常信息
public void printStackTrace();

异常抛出：任何Java代码都可以抛出异常，如：自己编写的代码、来自Java开发环境包中代码，或者Java运行时系统。无论是谁，都可以通过Java的throw语句抛出异常。从方法中抛出的任何异常都必须使用throws子句。 异常捕获：捕捉异常通过try-catch语句或者try-catch-finally语句实现。 总体来说，Java规定：对于可查异常必须捕捉、或者声明抛出。允许忽略不可查的RuntimeException和Error。

public class Outer {
   
        public void innerTest2() throws Exception{
         
        }
    }

    public static void main(String[] args) {
        Outer outter=new Outer();
   
        try {
            outter.innerTest2();
        }catch (Exception e){
            System.out.println(e);//此处调用了异常类的toString()
        }
        finnally{
            ...
        }
    }
}
public class Except {
    int a=0;
    int b=2;
    public void test(){
        try{
            if (a==0){
                throw new ArithmeticException();//主动抛出异常
            }
            System.out.println(a/b);
        }catch (ArithmeticException e){
            System.out.println(e);
        }finally {
            System.out.println("这是一个默认处理语句,在catch不到异常时才执行");
        }
    }
}

创建自己的异常类

public class Excep extends Exception {
    String myException;
    public Excep(String myException){
        this.myException="这是我自己定义的异常类";

    }
    public String toString(){
        return myException;
    }

}
class ThrowsEX {
    public void test() throws Excep{
        System.out.println("测试自己的异常类");

    }

    public static void main(String[] args) {
        try {
            new ThrowsEX().test();
        }catch (Excep e){
            System.out.println(e);

        }
    }
}

风吹pp凉~
关注
专栏目录
JavaSE基础篇
Devil_DiabLo的博客
02-21 143
文章目录一. 函数方法重载可变参数静态方法与非静态方法值传递，引用传递二. 数组初始化Arrays类三. 面向对象OOP构造方法三大特性static关键字抽象类接口内部类 一. 函数 方法重载 函数名相同，参数不同 可变参数 public void test(int... a){ } 静态方法与非静态方法 静态方法：可以直接使用类名调用，生命周期与类一致。 非静态方法：需要new一个对象来调用，生命周期与实例一致。 值传递，引用传递 //值传递 public void test(int a){}
JavaSe基础篇1
gaozhen666的博客
03-02 226
JavaSe基础篇1 1. 新手编程注意点 类名和文件名并非必须要保持一致，但是被public修饰的类需要与文件名保持一致 一个java文件中可以存在多个类，但只能存在一个被public修饰的类 当对一个java文件进行编译时，会对所有的类进行编译 main方法是程序的入口，找到main方法会逐行从上到下执行 一个类中可以没有main方法，这个类就不能自主运行，只能被调用运行 一个类可以存在多个方法，但只能存在一个main方法 2. 注释 注释即用于解释代码的文字，根据不同情况的需求分为三种类型。 2.
JavaSe基础篇4
gaozhen666的博客
03-07 154
JavaSe基础篇4 1. break与continue break 作用：结束终止 应用场景：用于循环|switch语句 continue 作用：结束本次循环直接进入到下一次循环 应用场景：用于循环语句 小练习： //1~10直接的数字,跳过3或者3的倍数 for(int i=1;i<=10;i++){ if(i%3==0){ continue; } System.out.println(i); } //死循环需要结合break关键字 int i=
JavaSE基础篇(下)
Seven67767的博客
08-10 264
JavaSE基础篇(下)
JavaSE基础篇：枚举
热门推荐
七叔的博客
12-24 1万+
JavaSE基础篇：枚举
JavaSE基础篇：instanceof关键字
七叔的博客
05-24 1万+
JavaSE基础篇：instanceof关键字
JavaSE基础
weixin_45536650的博客
11-13 439
javase
JavaSE基础篇（一）
宿命的博客
10-24 261
一、Java数据类型 > 1、基本数据八大类型 (1)、byte：属于整数类型，用1个字节来存储，byte类型的默认值也为0。 (2)、short：属于整数类型，用2个字节存储，short类型的默认值为0，一般情况下，因为Java本身转型的原因，可以直接写为0。 (3)、int：属于整数类型，用4个字节存储，int类型的默认值为0。 (4)、long：属
JavaSE基础篇：泛型说明
七叔的博客
12-17 1万+
JavaSE基础篇：泛型说明
javaSE基础篇之char
孤夜的博客
11-10 282
以下为个人观点及网上总结： 1：概念 char字符类型，八大基本类型的一种；2字节16位，在java中一个汉字或一个任意英文字符； 2：关于char为整数型 char n='好'; int k=(int)n;//类型转换 System.out.println(k);//结果为22909 /* 因为char在Ascll等字符编码中有对应的数值 **/ 3：声明 //声明1 char a='a';/...
黑马程序员javase基础篇学习笔记
12-31
百度网盘:https://pan.baidu.com/share/init?surl=MrgIiB2bfqRQL5NuJwTRug 提取码:2807
JavaSE基础篇 -- IO流的详细操作
07-28
本资源内详尽描述了Java基础的IO操作，包括基本的文件读取、写入、复制、分割、合并等动作，详情另可参见我的博客http://blog.csdn.net/zhongkelee/article/details/47061013
JavaSE基础篇 -- System,Math,Date,CalendarAPI实例
07-11
本压缩包详尽列举了JavaAPI当中的System、Runtime、Math、Date、Calendar类的实例，特别是日期格式与字符串格式的各种灵活转换。更多内容请参见：http://blog.csdn.net/zhongkelee
JavaSE基础篇 -- eclipse快捷键大全，JDK_API，String及相关类，模拟用户登录案例
07-02
JavaSE基础篇是Java编程初学者必经的学习阶段，涵盖了Java开发环境的配置、基本语法、数据类型、控制结构以及面向对象编程等基础知识。在这个主题中，我们将重点关注三个方面：Eclipse IDE的快捷键、JDK API的理解...
JavaSE基础篇 -- 集合框架详述_超集大合集
07-11
本压缩包详述描述了Java的集合框架，用详尽的源码实例，深入浅出的介绍了包含List、Set、Map、泛型在内的所有内容。登录我的博客http://blog.csdn.net/zhongkelee还有惊喜！利用集合框架实现了斗地主洗牌发牌实例。
[自用，更新自day5]瑞吉外卖代码及笔记
最新发布
lapiii的博客
11-01 451
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
基于vue框架的的汇生活家居商城的设计与实现bdjlq（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
h2345678的博客
10-29 1304
项目功能：商品分类,商品信息,用户。
（1）Java 编程基础概览：数据类型、常量、变量、标识符与运算符
码界领航的Cherry Yang的博客
10-28 1058
8 位，占1个字节，有符号的，范围 -128（-2^7）至 127（2^7-1）。32 位，占4个字节，范围 -2,147,483,648（-2^31）至 2,147,483,647（2^31 - 1）。Java 提供了六种数字类型，其中四个为整数类型，两个为浮点类型，还有字符类型，以及布尔型。16 位，占2个字节，范围 -32768（-2^15）至 32767（2^15 - 1）64 位，占8个字节，范围 -2^63 至 2^63 - 1。16 位 Unicode 字符，占 2 个字节。
SpringSession源码分析
lkr_lkr的博客
11-01 156
默认对常规Session的理解和使用，如何使用Set-Cookie。
Java面试必备：JAVASE基础深度解析
在Java面试中，基础的JAVASE部分是必不可少的考察点。这篇文档可能包含了以下重要的Java基础知识： 1. 面向对象特性：面向对象编程是Java的核心，其特征包括抽象、封装、继承和多态。抽象是通过类来表示现实世界中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值