JavaSE基础学习

qq_53629331

已于 2022-08-27 11:44:06 修改

阅读量289

点赞数

文章标签：学习算法 java

于 2022-06-22 15:12:48 首次发布

本文链接：https://blog.csdn.net/qq_53629331/article/details/125372116

版权

一、常用的dos命令

1. 切换盘符-----‘盘’+‘:’ (前提是要切换的盘符存在)
切换到C盘------C:
切换到D盘------D:
切换到E盘------E:
2. 查看当前目录下的所有文件------dir
3. 进入同目录下的文件------‘cd’ + ’ ’ + ‘文件名’
返回上一级------‘cd’ + ‘…’
4. 清理屏幕------cls
5. 退出终端------exit
6. 查看电脑IP------ipconfig
7. 创建目录------md
创建文件------‘cd’+‘>’
删除目录下的文件------del
删除目录------rd

二、注释

1.单行注释

//...

2.多行注释

/*
...
...
...
*/

3.JavaDoc文档注释

/**
* @...
* @...
* @...
*/

三、标识符和关键字

1 所有标识符都要以字母或美元符或下划线开始
2.不能使用关键字作为变量名或方法名
3.标识符是大小写敏感的

四、数据类型

1.数据类型是强类型语言，所有变量必须先定义后才能使用
2.java的数据类型分为基本类型和引用类型：
(1) 基本类型包括数值类型（即整数类型< byte占1个字节、short占2个字节、int占4个字节、long占8个字节 >、浮点类型< float占4个字节、double占8个字节 >、字符类型< char占2个字节 >）和 boolean类型< 占1位 true和false >
(2) 引用类型包括类、接口、数组

//整数
int n1 = 10 ；
byte n2 = 20 ;
short n3 = 30 ;
long n4 = 30L ;

//小数
float n5 = 50.1F ;
double n6 = 3.141592354845 ;

//字符
char name = ' 名 ' ;

//字符串类型String（不是关键字，是类）
String name = " 名字 " ;

//布尔值
boolean flag = true ;

3.概念
(1) 位（bit）：是计算机内部数据储存的最小单位
(2) 字节（byte）：是计算机数据处理的基本单位
(3) 字符：是指计算机中使用的字母、数字、字和符号
(4) 扩充：
1 bit 表示1位
1 Byte 表示一个字节，1 B = 8 b
1024 B = 1 KB
1024 KB = 1 M
1024 M = 1 G

4.扩展
(1) 整数扩展：
二进制 0b 、八进制 0 、十进制、十六进制 0x

int i1 = 10 ; //输出 10
int i2 = 010 ; //输出 8
int i3 = 0x10 ; //输出 17

(2)浮点数扩展：
float 和 double 不要用于比较
浮点数的特点：有限、离散、舍入误差、接近但不等于
例如：

public class Demo01 {
    public static void main(String[] args) {
        float f=0.1f;
        double d=1.0/10;
        System.out.println(f==d);//false

        float a=12121212122f;
        double b=a+1;
        System.out.println(a==b);//true
    }
}

5.类型的转换：
(1)自动转换
从低到高：
byte,short,char -> int -> long -> float -> double
(2)强制转换
从高到低：
（类型）变量名
(3) 注意：
（1）不能对布尔值进行转换
（2）转换时需要注意内存溢出问题或精度问题
（3）操作过大时，需要注意溢出问题

public class Demo02 {
    public static void main(String[] args) {
        int i = 10;
        byte b=(byte) i;//强制转换
        System.out.println(b);

        int money=10_0000_0000;
        int year=20;
        long add= (long)money*year;//在计算时已经出现了问题，需要计算过程转变为long类型才可以正常显示
        System.out.println(add);
    }
}

五、变量和常量

1.变量的创建

// 数据类型 变量名 = 值;   可以用逗号隔开来声明多个类型的变量
String name = "mike" ;
int age = 15 ;

2.变量的分类
(1) 类变量 -----static
随类的出现而出现，随类的消失而消失，可以直接访问
初始值为0、0.0、null，false
(2)实例变量
从属于对象，初始值为0、0.0、null，false
(3)局部变量
必须进行生声明和初始化

public class Demo04 {
    static double salary;//类变量

    String name;//实例变量

    public void method(){
     int a=0;//局部变量
    }

    public static void main(String[] args) {
        System.out.println(salary); //0.0  直接访问类变量

        Demo04 demo04= new Demo04();
        System.out.println(demo04.name);//null  访问实例变量
    }
}

3.常量 -----final

static final double salary=500;

六、命名规范

1.类成员变量：首字母小写和驼峰原则 -----monthSalary
2.局部变量：首字母小写和驼峰原则 -----monthSalary
3.常量：大写字母和下划线 -----MONTH_SALARY
4.类名：首字母大写和驼峰原则 -----MonthSalaty
5.方法名：首字母小写和驼峰原则 -----monthSalary()

七、JavaDoc（javadoc命令是用来生成自己的API文档）

相关参数：
@author 作者名
@version 版本号
@since 需要的jdk版本
@param 参数名
@throws 异常抛出情况
@return 返回值情况

八、用户交互Scanner

Scanner scanner = new Scanner(System.in);//扫描所输入的内容

例如：
next() 与 nextLine()
next() 所输出的是所输入的内容中空格前的内容
nextLine() 所输出的是回车之前的所有内容

package com.zhang.scanner;
import java.util.Scanner;
public class Demo03 {
    public static void main(String[] args) {
        //创建扫描机器
        Scanner scanner = new Scanner(System.in);
        
        System.out.println("请输入数据：");
       
        String str = scanner.nextLine();//输出想要的类型的内容，这里为nextLine()类型的内容
        
        System.out.println("用户输入的数据为："+str);//如果输入的是hello world，则输出为hello world；使用next()，则输出的是hello
        scanner.close();
    }
}

九、结构

1.顺序结构：从上到下的结构
2.if 选择结构

  （1）单选择结构
if (布尔值表达式){
    // 布尔值为真将输出的内容
    ...
}

（2）双选择结构
if (布尔值表达式){
    // 布尔值为true
}else{
    //布尔值为false
}

（3）多选择结构(有一个if是true，其他的就都不执行)
if (布尔值表达式1){
    ...
}else if(布尔值表达式2){
    ...
}else if(布尔值表达式3){
    ...
}else{
    ...
}

3.switch 选择结构

switch (expression){
    case value :
        ...//执行语句
        break;//防止向下穿透
    case value :
        ...//执行语句
        break;//防止向下穿透
    default :
        //其他情况
}

4.循环结构
（1）while 循环（先判断后执行）
（2）do…while 循环（先执行后判断）
（3）for 循环

for ( 初始化 ; 布尔表达式 ; 更新){
    ...
}

// 增强 for 循环（主要用于遍历数组和集合对象）
for ( 声明语句 : 表达式 ){
    ...
}

十、break、continue

1.break：用于任何循环体中的主体部分，强行退出循环，不执行循环中剩余的部分
2.continue：用于循环语句中，终止某次循环，跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定

十一、方法

修饰符 返回值类型 方法名（参数类型 参数值）{
    ...
    // 方法体
    ...
    return 返回值 ;// return 是结束方法，返回一个结果  ;  break 是switch中结束循环
}

1.修饰符：定义了该方法的访问类型，可选
2.参数类型：当方法被调用时，传递值给参数；分为形式参数和实际参数
（1）形参：在方法被调用时用于接收外界输入的数据
（2）实参：调用方法时实际传给方法的数据
3.方法体：定义该方法的功能
4.方法的重载：
（1）方法名称必须相同
（2）参数列表必须不同（个数、类型、参数排序顺序不同等）
（3）方法的返回值可以相同也可以不同
（4）只有返回值类型不同不足以成为方法的重载

十二、可变参数（不定项参数）

1.在声明方法中，在指定参数类型后加一个省略号（…）
2.注意：一个方法中只能定义一个可变参数，他必须是方法的最后一个参数，任何普通的参数必须在他之前声明

public static void main(String[] args) {
        //调用可变参数的方法
        printMax(1,23,46,8,2,56,13,852);
        printMax(new double[]{2,452,6,5,23,5,2,3});
    }
    //输出最大值
    public static void printMax(double...numbers){
        if(numbers.length==0){
            System.out.println("没有找到数");
            return;
        }

        double result=numbers[0];
        //排序
        for (int i=1;i<numbers.length;i++){
            if (numbers[i]>result){
                result=numbers[i];
            }
        }
        System.out.println("最大值为"+result);
    }

十三、递归

递归方法就是自己调用自己，用于求解一些小规模问题的计算，大大减少程序的代码量。

    //阶乘
    public static void main(String[] args) {
        System.out.println(f(5));
    }
    public static int f(int a){
        if (a==0||a==1){
            return 1;
        }else if(a<0){
            System.out.println("请输入正数");
            return 0;
        }else {
            return a*f(a-1);
        }
    }

十四、数组

1.一维数组
（1）数组的声明

int[] arrary ;//首选方法
或
int arrary[] ;//效果相同，但不是首选方法

（2）静态初始化数组

int[] a = { 1 , 2 , 3 , 4 , 5 } ;

（3）动态初始化数组

int[] arrary = new int[10] ;
arrary[0]=...;

2.二维数组

int[][] arrarys = new int[2][3] ;// 二行三列的数组

3.Arrays工具类：
常用功能：
（1）给数组赋值：通过fill方法

public static void fill(int[] a , int val) 

//将指定的int值分给指定的int数组的每个元素
//a - 要填充的数组 
//val - 要存储在数组的所有元素中的值

public static void fill(int[] a , int fromIndex , int toIndex , int val) 

//将指定的int值分配给指定的int数组的指定范围的每个元素。 要填充的范围从索引fromIndex扩展到索引toIndex ，排他。（如果fromIndex==toIndex ，要填充的范围是空的。） 
//a - 要填充的数组 
//fromIndex - 要用指定值填充的第一个元素（包括）的索引 
//toIndex - 要用指定值填充的最后一个元素（排除）的索引 
//val - 要存储在数组的所有元素中的值

（2）对数组排序：通过sort方法

public static void sort(int[] a)
//按照数字顺序排列指定的数组

（3）比较数组：通过equals方法

public static boolean equals(int[] a1 , int[] a2)
//如果两个指定的int数组彼此包含相同数量的元素、所有对应的元素对都相等相等 ，则返回true

（4）查找数组元素：通过binarySearch方法对排序好的数组进行二分查找法操作

import java.util.Arrays;
public class Demo02 {
    public static void main(String[] args) {
        int[] a = {56,1,48,64,2,6,78,81,};
        System.out.println(Arrays.toString(a));//[56, 1, 48, 64, 2, 6, 78, 81]

        Arrays.sort(a);
        System.out.println(Arrays.toString(a));//[1, 2, 6, 48, 56, 64, 78, 81]

        Arrays.fill(a,2,4,0);//在2<=x<4之间填充0
        System.out.println(Arrays.toString(a));//[1, 2, 0, 48, 56, 64, 78, 81]
    }
}

4.冒泡排序

public class Demo03 {
    public static void main(String[] args) {
        int[] a={1,265,254,951,5,25,3852,};
        System.out.println(Arrays.toString(a));
        sort(a);
        System.out.println(Arrays.toString(a));
    }

    public static int[] sort(int[] a){
        //外层循环，判断走多少次
        for (int i=0;i<a.length-1;i++){
            //内层循环，两两比较
            for (int j=0;j< a.length-1-i;j++){
                if (a[j]>a[j+1]){
                    int temp=a[j+1];
                    a[j+1]=a[j];
                    a[j]=temp;
                }
            }
        }
        return a;
    }
}

5.稀疏数组

public class Demo04 {
    public static void main(String[] args) {
        int[][] a1=new int[5][5];//定义数组
        a1[1][1]=1;
        a1[2][2]=2;//赋值

        System.out.println("原始数组：");
        //遍历a1
        for(int[] a:a1){
            for (int b:a){
                System.out.print(b+" ");
            }
            System.out.println();
        }

        //创建稀疏数组
        System.out.println("稀疏数组为：");
        //判断数组中非0元的个数数
        int sum=0;
        for (int i=0;i< 5;i++){
            for (int j=0;j<5;j++){
                if (a1[i][j]!=0){
                    sum++;
                }
            }
        }
        //稀疏数组的第0行
        int[][] a2=new int[sum+1][3];
        a2[0][0]=5;
        a2[0][1]=5;
        a2[0][2]=sum;
        //稀疏数组的其他行
        int count=0;
        for (int i=0;i<a1.length;i++){
            for (int j=0;j<a1[i].length;j++){
                if (a1[i][j]!=0){
                    count++;
                    a2[count][0]=i;
                    a2[count][1]=j;
                    a2[count][2]=a1[i][j];
                }
            }
        }
        //遍历稀疏数组

        for(int[] a:a2){
            for (int b:a){
                System.out.print(b+" ");
            }
            System.out.println();
        }

    }
}
/*
结果：
原始数组：
0 0 0 0 0 
0 1 0 0 0 
0 0 2 0 0 
0 0 0 0 0 
0 0 0 0 0 
稀疏数组：
5 5 2 
1 1 1 
2 2 2 
*/

十五、面向对象

1.面向对象思想：分类的思维模式，首选思考问题如何分类，再对分类好的各个问题进行单独的思考解决；适合处理复杂的问题。（面向过程思想：思考问题步骤清晰简单，适合处理一些较为简单的问题）
2.面向对象的本质：以类的方式组织代码，以对象的组织封装数据
3.面向对象的三大特性：封装、继承、多态

十六、方法的调用

1. 静态方法的调用：直接调用
2. 非静态方法的调用：使用new实例化类后进行调用

public class Demo01 {
    public static void main(String[] args) {
        //直接调用静态方法
        Student.say();

        //调用非静态方法   实例化这个类---new
        //对象类型 对象名 = 对象值
        Student student=new Student();
        student.sayHello();
    }
}

//学生类
public class Student {
    //静态方法
    public static void say(){
        System.out.println("说话");
    }

    //非静态方法
    public void sayHello(){
        System.out.println("你好");
    }
}

3. 静态方法：和类一起加载的，随类的出现而出现，随类的消失而消失
非静态方法：被实例化之后才存在
4. 值传递与引用传递

//值传递
public class Demo03 {
    public static void main(String[] args) {
        int a=1;
        System.out.println(a);// 1
        Demo03.change(a);
        System.out.println(a);// 1
    }
    public static void change(int a){
        a=10;
    }
}

//引用传递：对象
public class Demo04 {
    public static void main(String[] args) {
        //实例化类
        Person person=new Person();
        System.out.println(person.name);//null
        Demo04.change(person);
        System.out.println(person.name);//老王
    }
    public static void change(Person person){
        person.name="老王";
    }
}
class Person{
    String name;
}

十七、类和对象的创建

//学生类
public class Student {
    //属性：字段
    String name;
    int age;
    
    //方法
    public void study(){
        System.out.println(name+"在学习");
    }
}

public class Text {
    public static void main(String[] args) {
        //实例化类
        //student就是一个Student类的具体实例
        Student student = new Student();

        Student xiaoming=new Student();
        Student xiaohong=new Student();

        xiaoming.name="小明";
        xiaoming.age=15;
        System.out.println(xiaoming.name);// 小明
        System.out.println(xiaoming.age);// 15
        xiaoming.study();// 小明在学习

        xiaohong.name="小红";
        xiaohong.age=14;
        System.out.println(xiaohong.name);// 小红
        System.out.println(xiaohong.age);// 14
        xiaohong.study();// 小红在学习
    }
}

十八、构造器

1.构造器：与类名同名；没有返回值；分为无参构造器和有参构造器
2. 构造器的作用：new本质上是在调用构造方法；初始化对象的值
3. 注意：无参构造器默认存在类中，无需定义；但当定义了有参构造之后，想要调用无参构造就必须定义无参构造器后才可调用

public class Person {
    String name;
    int age;

    //有参构造器
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }

    //无参构造器   默认为空，可以在里面初始化值
    public Person(){
        this.name = "zhang";
    }

    public void work(){
        System.out.println(age+"岁的"+name+"在工作");
    }

    //构造器快捷键----alt+insert
}

public class Text {

    public static void main(String[] args) {
        //调用有参构造器
        Person wang = new Person("wang",18); // wang
        System.out.println(wang.name); // 18
        System.out.println(wang.age); // 18岁的wang在工作
        wang.work();

        //调用无参构造器（类中默认存在，不用定义，但当存在有参构造器时，想要调用无参构造器就需要定义无参构造器）
        Person person=new Person();
    }
}

十九、封装

使用private，属性私有，使用get、set方法调用（高内聚、低耦合）

public class StudentPrivate {
    private String name;
    private int age;
    private char sex;

    public int getAge(){
        return age;
    }

    public void setAge(int age){
        if (age<0||age>130){
            this.age=0;
        }else {
            this.age = age;
        }
    }
    // alt+insert 快捷键
}

二十、继承（extends）

1.继承关系的俩个类，一个为子类（派生类），一个为父类（基类）；子类继承父类使用关键字extends来表示
2. java中只用单继承，没有多继承；即一个子类只能有一个父类，但一个父类可以有多个子类
3. 在java中所有类都默认直接或间接继承object类
4. super：
注意点：
（1）super调用父类构造方法，必须在构造方法的第一个
（2）super必须只能出现在子类的方法或构造方法中
（3）super 和 this 不能同时调用构造方法
super与this的区别：
（1）this本身调用这个对象；super代表父类对象的引用
（2）this没有继承也可以使用；super只能在继承条件下才可以使用
（3）this() 是本类的构造；super() 是父类的构造
5. 方法的重写：
（1）需要有继承关系，子类重写父类
（2）参数列表必须相同
（3）修饰符：范围可以扩大但不能缩小：public > project > default > private
（4）抛出的异常：范围可以缩小，但不能扩大
（5）重写时子类的方法和父类必须一致，方法体不同

二十一、多态

1.多态性，即一个方法可以根据发送对象不同而采用不同的行为方式
2. 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

// 一个对象的类型是确定的
例如
new Student();
new Person();
//但是指向的对象引用类型很多
例如
Student s1 = new Student();
Person s2 = new Student();
Object s3 = new Student();

3.多态是方法的多态，属性没有多态

二十二、instanceof和类型转换

1.instanceof

System.out.println(X instanceof Y);//判断X与Y是否有关系

2.类型转换

//高类型转低类型
Person s1 = new Student();
(Student)s1.work();  //其中work()是Student类中的方法，Person类型的s1需转为Student类型才能调用

二十三、static

1.静态属性和静态方法可以直接通过类名进行调用
2. 静态代码块

    //赋初始值
    {
        System.out.println("匿名类");
    }

    //只执行一次
    static {
        System.out.println("静态类");
    }

    public Person(){
        System.out.println("构造方法");
    }

二十四、抽象类—abstract

1.不能new这个抽象类，只能靠子类重写去实现他；
2. 抽象类中可以写普通方法
3. 非抽象类不能写抽象方法

//抽象类
public abstract class A {
    
    //抽象方法
    public abstract void eat();

    //构造器
    public A() {
    }

    //普通方法
    public void work(){}
}

二十五、接口

1.定义接口类型--------interface
2. 继承接口-------implements
3. 抽象类只能实现单继承，接口可以实现多继承
4. 接口不能被实例化，接口中没有构造方法
5. 必要时需要重写接口中的方法
6. 接口在所有定义的属性都是抽象的----public static final；接口在所有定义的方法都是抽象的----public abstract

public interface TimeService {
    void timer();
}

public interface UserService {

    //接口在所有定义的属性都是抽象的---public static final
    int age=11;

    //接口在所有定义的方法都是抽象的---public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

//抽象类  static
//类 可以实现接口  implements
//实现了接口，需要重写接口中的方法
//接口可以实现多继承，抽象类只能实现单继承
public class Impl implements UserService,TimeService{
    @Override
    public void timer() {

    }

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }
}

二十六、内部类

1.成员内部类

public class Outer {
    private int age=50;

    public void outer(){
        System.out.println("这是外部类");
    }

    public class Inter{
        public void inter(){
            System.out.println("这是内部类");
        }

        //可以访问外部类的私有属性
        public int getAge(){
            return age;
        }
    }

}

public class text {
    public static void main(String[] args) {
        //实例化外部类
        Outer outer=new Outer();
        outer.outer();
        //通过内部类实例化外部类
        Outer.Inter inter=outer.new Inter();
        inter.inter();
        System.out.println(inter.getAge());
    }

}

2.静态内部类

public class Outer {
    private int age=50;

    public void outer(){
        System.out.println("这是外部类");
    }

// 静态内部类
    public static class Inter{
        public void inter(){
            System.out.println("这是静态内部类");
        }

    }

}

3.局部内部类

public class Outer {
    public void method(){
        //局部内部类
        class Inter{

        }
    }

}

4.匿名内部类

public class App {
    public static void main(String[] args) {
        //没有名字初始化类，不用讲实例化保存到变量中
        //匿名类
        new Apple().eat();
        new UserService(){

            @Override
            public void hello() {
                
            }
        };
    }
}
//一个java文件只能有一个public class，但是可以有多个class
class Apple{
    public void eat(){
        System.out.println("eat");
    }
}

interface UserService{
    void hello();
}

二十七、异常

（1）处理异常的五个关键字：
try、catch、finally、throw、throws
（2）异常的包含关系：
在这里插入图片描述

public class Text2 {
    public static void main(String[] args) {
        int a=0;
        int b=0;
        //ctrl+alt+t----快捷键
        //如果要捕获多个异常，要从小到大
        try {
            System.out.println(a/b);
        } catch (ArithmeticException e) {
            System.out.println("b不能为0");
            e.printStackTrace();
        }catch(Exception e){
            System.out.println("Exception");
        }catch(Error e){
            System.out.println("Error");
        }catch (Throwable e){
            System.out.println("Throwable");
        } finally {
            System.out.println("finally");
        }//finally  可以不要，一般用于IO流、资源关闭等
    }
}

public class Text {
    public static void main(String[] args) {

        try{
            new Text().test(1,0);
        }catch (ArithmeticException e){
            e.printStackTrace();
        }

    }

    public void test(int a,int b) throws ArithmeticException{
        if(b==0){
            throw new ArithmeticException();//主动抛出异常，一般在方法中使用
        }
    }
}

（3）自定义异常

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

    //数字>10  异常
    private int age;

    public MyException(int a){
        this.age=a;
    }

    //toString   快捷键----alt+insert


    @Override
    public String toString() {
        return "MyException{" +
                "age=" + age +
                '}';
    }
}

public class Test {

    //可能会存在异常的方法
    static void test(int a) throws MyException{
        System.out.println("数值为："+a);
        if(a>10){
            throw new MyException(a);
        }
        System.out.println("OK");
    }

    public static void main(String[] args){
        try {
            test(11);
        } catch (MyException e) {
            System.out.println("MyException->"+e);
            e.printStackTrace();
        }
    }

}