JavaSE零基础学习笔记

最新推荐文章于 2023-11-02 23:04:27 发布

virlorenzxx

最新推荐文章于 2023-11-02 23:04:27 发布

阅读量333

点赞数 1

文章标签： java 面向对象编程 javase

本文链接：https://blog.csdn.net/JRmentos/article/details/116644092

版权

JavaSE零基础学习笔记

前言

java学习路线

博客

养成写博客的习惯
写CSDN博客，总结自己的学习
搭建自己的个人博客网站（可用开源框架去搭建，如WordPress、typecho）

DOS命令

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RDoOy1tb-1620700246708)(E:/note_pictures/JavaSE学习笔记/QQ截图20210506105545.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zOUaSjD2-1620700246711)(E:/note_pictures/JavaSE学习笔记/QQ截图20210506105603.png)]

java三大版本

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ISS0zYN2-1620700246714)(E:/note_pictures/JavaSE学习笔记/QQ截图20210506111002.png)]

JDK、JRE、JVM

JDK: Java Development Kit

JRE: Java Runtime Environment

JVM: Java Virtual Machine

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8RCMsKoS-1620700246716)(E:/note_pictures/JavaSE学习笔记/Snipaste_2021-05-06_14-08-11.png)]

java基础语法

Hello World

随便新建一个文件夹，存放代码
新建一个Java文件
编写代码

public class Hello{
    public static void main(String[] args){
        System.out.print("Hello World!");        
    }
}

编译 javac java文件，会生成一个class文件
运行class文件，java class文件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Jq6ZYIBI-1620700246717)(E:/note_pictures/JavaSE学习笔记/Snipaste_2021-05-06_14-36-03.png)]

java中的注释有三种

单行注释 //
多行注释
```
 /*
  */
```
文档注释
```
/**
 * 
 */
```

java关键字

java转义字符

注：

boolean flag=true;
if (flag==true){}
if(flag){}//两者是相同的含义

类型转换

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GHKgLV23-1620700246718)(E:/note_pictures/JavaSE学习笔记/QQ截图20210506152554.png)]

//强制转换  (类型)变量名  高到低
//自动转换  低到高

1. 不能对布尔值进行转换
2. 不能把对象类型转换为不相干的类型
3. 在把高容量转换到低容量的时候，强制转换
4. 转换的时候可能存在内存溢出，或者精度问题

变量

变量作用域：

类变量

实例变量

局部变量

public class Demo02 {
    //类变量  static
    static double salary =2500;
    //属性：变量

    //实例变量：从属于对象;如果不自行初始化，这个类型的默认值0 0.0
    //布尔值默认为false，除了基本类型，其余都是null
    String name;
    int  age;
    //main方法
    public static void main(String[] args) {

        //局部变量：必须声明和初始化
        int i = 10;//只在此代码段中能用
        System.out.println(i);

        //变量类型 变量名字 = new Demo02()
        Demo02 demo02 = new Demo02();
        System.out.println(demo02.age);
        System.out.println(demo02.name);
        //类变量 static
        System.out.println(salary);
    }
    //其他方法
    public void add() { }
}

常量

初始化后不能再改变值，常量名一般使用大写字符

public class Demo03 {
    //修饰符，不存在先后顺序
    static final double PI=3.14;

    public static void main(String[] args) {
        System.out.println(PI);
    }
}

变量的命名规范

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hgwhJw5o-1620700246718)(E:/note_pictures/JavaSE学习笔记/QQ截图20210506161444.png)]

CTRL+D 为复制当前行到下一行

//幂运算 2^3 
double pow = Math.pow(2, 3);
System.out.println(pow);

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-62keJRYT-1620700246719)(E:/note_pictures/JavaSE学习笔记/QQ截图20210506162415.png)]

输出：1020

30

import xxx.*  //导入该包下的全部类

JavaDoc

javadoc命令是用来生成自己API文档

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VXhcT9Ln-1620700246720)(E:/note_pictures/JavaSE学习笔记/Snipaste_2021-05-06_19-40-34.png)]

Scanner对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3tuTfllt-1620700246721)(E:/note_pictures/JavaSE学习笔记/QQ截图20210507083029.png)]

package com.ocean.scanner;

import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {
        //创建一个扫描器对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("使用nextLine方式接收：");
        //判断用户有没有输入字符串
        if (scanner.hasNextLine()){
            //使用nextLine方式接收
            String str = scanner.nextLine();
            System.out.println("输出的内容为："+str);
        }
        scanner.close();  //凡是属于IO流的类如果不关闭会一直占用资源，要养成好习惯用完就关掉
    }
}

增强for循环

package com.ocean.operate;

public class a {
    public static void main(String[] args) {
        int[] num = {1,2,3,4,5,6};

        //遍历数组的元素
        for (int x :num) {
            //把数组每一项取出来赋值给x
            System.out.println(x);
        }
    }
}

方法

方法的定义

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yBcThngw-1620700246721)(E:/note_pictures/JavaSE学习笔记/QQ截图20210507084929.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-waw0Bekw-1620700246722)(E:/note_pictures/JavaSE学习笔记/QQ截图20210507085343.png)]

注：java都是值传递

方法的重载

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iVUgxDW0-1620700246723)(E:/note_pictures/JavaSE学习笔记/QQ截图20210507090957.png)]

可变参数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VxpClJoe-1620700246724)(E:/note_pictures/JavaSE学习笔记/QQ截图20210507091957.png)]

递归

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hLPALXhZ-1620700246724)(E:/note_pictures/JavaSE学习笔记/QQ截图20210507092329.png)]

作业（简易计算器）

package com.ocean.method;

import java.util.Scanner;

public class Cal {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String str =scanner.next();
        int i = scanner.nextInt();
        int j = scanner.nextInt();
        switch (str){
            case "+":
                System.out.println(add(i,j));
                break;
            case "-":
                System.out.println(sub(i,j));
                break;
            case "*":
                System.out.println(mul(i,j));
                break;
            case "/":
                System.out.println(div(i,j));
                break;
        }
    }

    public static int add(int a,int b){
        return a+b;
    }
    public static int sub(int a,int b){
        return a-b;
    }
    public static int mul(int a,int b){
        return a*b;
    }
    public static int div(int a,int b){
        return a/b;
    }

}

数组

package com.ocean.array;

public class ArrayDemo01 {

    public static void main(String[] args) {
        int[] nums = new int[10];
        int sum = 0;
        nums[0] = 10;
        nums[1] = 10;
        nums[2] = 10;
        nums[3] = 10;
        nums[4] = 10;
        nums[5] = 10;
        nums[6] = 10;
        nums[7] = 10;
        nums[8] = 10;
        nums[9] = 10;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        System.out.println(sum);
    }
}

数组初始化

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nyl2zNjx-1620700246725)(E:/note_pictures/JavaSE学习笔记/QQ截图20210507100136.png)]

四个基本特点

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mIEeD0ji-1620700246726)(E:/note_pictures/JavaSE学习笔记/QQ截图20210507100353.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xNUvuclc-1620700246726)(E:/note_pictures/JavaSE学习笔记/QQ截图20210507100433.png)]

数组的使用

package com.ocean.array;

public class ArrayDemo02 {
    public static void main(String[] args) {
        int[] arrays = {1, 2, 3, 4, 5, 6};
        printArray(arrays);
        int[] rev = reverse(arrays);
        printArray(rev);

    }
    //打印数组
    public static void printArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
    //反转数组
    public static int[] reverse(int[] arr) {
        int[] result = new int[arr.length];
        
        //反转操作
        for (int i = 0, j = result.length - 1; i < arr.length; i++, j--) {
            result[j] = arr[i];
        }
        return result;
    }
}

Arrays类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WujOVLpP-1620700246727)(E:/note_pictures/JavaSE学习笔记/QQ截图20210507104445.png)]

package com.ocean.array;

import java.util.Arrays;

public class ArrayDemo03 {
    public static void main(String[] args) {
        int[] a={1,2,3,6,59,84,578,46,126};
        System.out.println(a);
        //打印数组元素Arrays.toString
        System.out.println(Arrays.toString(a));
        Arrays.sort(a); //对数组进行排序,升序
        System.out.println(Arrays.toString(a));
        Arrays.fill(a,2,6,0); //数组填充
        System.out.println(Arrays.toString(a));
    }
}

冒泡排序

package com.ocean.array;

import java.util.Arrays;

//冒泡排序
public class ArrayDemo04 {
    public static void main(String[] args) {
        int[] a={1,5,9,7,8,5,6,3,7};
        int[] result = sort(a);
        System.out.println(Arrays.toString(result));
    }
    public static int[] sort(int[] arr){

        //临时变量
        int temp = 0;
        //外层循环，判断循环要走多少次
        for (int i = 0; i < arr.length-1; i++) {
     
            //内层循环
            for (int j = 0; j < arr.length-1-i; j++) {
                if (arr[j+1]<arr[j]){
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        return arr;
    }
}

面向对象编程

什么是面向对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xWzpgqp4-1620700246727)(E:/note_pictures/JavaSE学习笔记/QQ截图20210510161222.png)]

package com.ocean.oop.demo01;
public class Demo01 {
    public static void main(String[] args) {
    }

    //return结束方法，返回一个结果
    public String sayHello() {
        return "hello world";
    }
    public void Hello() {
        return;
    }
    public int max(int a, int b) {
        return a > b ? a : b;
    }
}

package com.ocean.oop.demo01;

public class Demo02 {

    public static void main(String[] args) {
        //实例化这个类  new
        Student student = new Student();
        student.say();
    }
}

package com.ocean.oop.demo01;

//学生类
public class Student {
    //非静态方法，需要实例化才能使用，如上代码
    public void say(){
        System.out.println("学生说话了");
    }
}

值传递和引用传递

package com.ocean.oop.demo01;
//引用传递：对象，本质还是值传递
//对象，内存
public class Demo03 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);//null
        Demo03.change(person);
        System.out.println(person.name);//OCEAN
    }

    public static void change(Person person) {
        //person是一个对象：指向的 ---> Person person = new Person();这是一个具体的人，可以改变属性!
        person.name = "OCEAN";
    }
}

//定义了一个Person类，有一个属性：name
class Person {
    String name;
}

类和对象的关系

一个类中只有两个内容：属性(字段)和方法
类是抽象的，需要把它实例化

创建和初始化对象

package com.ocean.oop.demo02;
//学生类
public class Student {
    //属性：字段
    String name;
    int age;

    //方法
    public void study(){
        System.out.println(this.name+"在学习");
    }
}

package com.ocean.oop.demo02;

//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {

        //类：抽象的，实例化
        //类实例化后，会返回一个自己的对象
        //student对象就是一个Student类的具体事例
        Student ming = new Student();
        Student hong = new Student();

        ming.name = "小明";
        ming.age = 22;
        System.out.println(ming.name);
        System.out.println(ming.age);

        hong.name = "小红";
        hong.age = 20;
        System.out.println(hong.name);
        System.out.println(hong.age);
    }
}

构造器

无参构造和有参构造

package com.ocean.oop.demo02;
//java---> class
public class Person {

    //一个类即使什么都不写，它也会存在一个方法
    //显式的定义构造器
    String name;
    int age;

    //alt+insert自动生成无参和有参构造、
    //使用new关键字，本质就是在调用构造器，用来初始化
    //无参构造
    public Person() {
        this.name = "OCEAN";
    }
    //有参构造：一旦定义了有参构造，无参就必须显式定义
    public Person(String name) {
        this.name = name;
    }

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

构造器：1. 和类名相同 2. 没有返回值
作用：1. new本质在调用构造方法 2. 初始化对象的值
注意点：1. 定义有参构造之后，就没有无参构造了。如果想使用无参构造，必须显式的定义一个无参构造

封装

private：私有
get/set方法，get获得这个数据，set给这个数据设置值

package com.ocean.oop.demo04;

//类  private:私有
public class Student {
    //属性私有
    private String name;//姓名
    private int id;//学号
    private char sex;//性别
    private int age;//年龄

    //get/set方法，get获得这个数据，set给这个数据设置值
    //alt+insert自动生成
    public String getName() {
        return name;
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public char getSex() {
        return sex;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age>120||age<0){
            this.age=3;//不合法
        }
        else {
            this.age=age;
        }
    }
}

package com.ocean.oop;

import com.ocean.oop.demo04.Student;

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("OCEAN");
        System.out.println(s1.getName());
        s1.setAge(999);//不合法的数据
        System.out.println(s1.getAge());
        s1.setAge(50);//合法的数据
        System.out.println(s1.getAge());
    }
}

封装作用：
1. 提高程序的安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 增加系统可维护性

继承

子类继承了父类，就拥有了父类的全部方法！
public、protected、default、private
CTRL + H 可显示父类子类关系树结构*
在java中所有类都默认直接或间接继承Object类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2HD9yuQF-1620700246728)(E:/note_pictures/JavaSE学习笔记/QQ截图20210510140452.png)]

super注意点:

1. super调用父类的构造方法时，必须在构造方法的第一个

2. super必须只能出现在子类的方法或者构造方法中！

3. super和this不能同时调用构造方法！
对比this：

代表的对象不同：

this：本身调用这个对象

super：代表父类对象的应用

前提不同：

this：没有继承也可以使用

super：只能在继承条件才可以使用

构造方法：

this()：本类的构造

super()：父类的构造

重写

重写都是方法的重写，与属性无关

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dgEnot5p-1620700246729)(E:/note_pictures/JavaSE学习笔记/QQ截图20210510143133.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-d5fTJizH-1620700246729)(E:/note_pictures/JavaSE学习笔记/QQ截图20210510143514.png)]

重写：需要有继承关系，子类重写父类的方法！
1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符：范围可以扩大但不能缩小，public >protected > default > private
4. 抛出的异常：范围可以被缩小，但不能扩大， ClassNotFoundException --> Exception(大)
重写，子类的方法和父类必须要一致，方法体（内容）不同
子类重写了父类的方法，父子都执行子类的方法
为什么需要重写
父类的功能，子类不一定需要，或不一定满足
快捷键Alt + Insert: Override

多态

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Jfn7IhBB-1620700246730)(E:/note_pictures/JavaSE学习笔记/QQ截图20210510151600.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Uk8xtknO-1620700246731)(E:/note_pictures/JavaSE学习笔记/QQ截图20210510150447.png)]

多态注意事项：
1. 多态是方法的多态，属性没有多态
2. 父类和子类，要有联系。又问题会出现类型转换异常：ClassCastException!
3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象！Father f1 = new Son();
4. 不能重写的：

static 是方法，属于类，不属于实例

final 常量

private 方法

X instanceof Y，X是不是Y的子类型

类型的转换

package com.ocean.oop;

import com.ocean.oop.demo06.Person;
import com.ocean.oop.demo06.Student;

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

        //类型之间的转换(父转子)
        //高                    低
        Person obj = new Student();
        Student student = (Student) obj;
        student.go();
        ((Student) obj).go();
    }
}

子类转换为父类，可能丢失自己的本来的一些方法

1. 父类引用指向子类的对象
2. 把子类转换为父类，向上转型，不用强制转换。如：Person person = student
3. 把父类转换为子类，向下转型，需要强制类型转换。
4. 可以方便方法的调用，减少重复的代码

static关键字详解

package com.ocean.oop.demo07;

public class Person {

    {
        //代码块(匿名代码块)
    }

    static {
        //静态代码块
    }
}

package com.ocean.oop.demo07;
//静态导入包~
import static java.lang.Math.random;
import static java.lang.Math.PI;

public class Test {

    public static void main(String[] args) {
        System.out.println(random());//随机数
        System.out.println(Math.random());//不导包的话这样写
        System.out.println(PI);
    }
}

通过final 修饰的类，不能被继承，没有子类

抽象类

package com.ocean.oop.demo08;

//abstract抽象类    extends:单继承    接口可以多继承
public abstract class Action {
    //方法约束
    //用在方法上就是抽象方法，只有方法名字，没有方法实现
    public abstract void doSomething();
}

package com.ocean.oop.demo08;
//抽象类的所有方法，继承了它的子类，都必须要实现它的方法。除非子类也是抽象的
public class A extends Action{
    @Override
    public void doSomething() {

    }
}

抽象类的特点
1. 不能new这个抽象类，只能靠子类去实现它,只是个约束
2. 抽象类里可以写普通方法，抽象方法必须在抽象类中

接口

interface定义的关键字，接口都需要有实现类
实现类一般会以”Impl“结尾
类可以实现接口通过"implements" 接口
"Alt + 回车"自动生成接口中需要实现的方法
可利用接口，实现“多继承”
抽象的思维

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0h5g4Fez-1620700246731)(E:/note_pictures/JavaSE学习笔记/QQ截图20210511084842.png)]

接口的作用
1. 约束
2. 定义一些方法，让不同的人实现
3. 接口不能被实例化，接口中没有构造方法
4. implements可以实现多个接口
5. 必须要重写接口中的方法

内部类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4kj93CIO-1620700246732)(E:/note_pictures/JavaSE学习笔记/QQ截图20210511084353.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZkdUU0na-1620700246733)(E:/note_pictures/JavaSE学习笔记/QQ截图20210511085326.png)]

一个java文件中只能有一个public类，但可以有多个class类，内部类除外

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jWpRjl4A-1620700246733)(E:/note_pictures/JavaSE学习笔记/QQ截图20210511085659.png)]

匿名内部类

package com.ocean.oop.demo10;

import com.ocean.oop.demo05.A;

public class Test {
    public static void main(String[] args) {
        new Apple().eat();
        new UserService() {
            @Override
            public void hello() {

            }
        };
    }
}

class Apple {
    public void eat() {
        System.out.println("eat");
    }
}

interface UserService {
    void hello();

}

异常

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VO7PXWqN-1620700246734)(E:/note_pictures/JavaSE学习笔记/QQ截图20210511091243.png)]

异常处理机制

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eAdjUXVX-1620700246734)(E:/note_pictures/JavaSE学习笔记/QQ截图20210511094724.png)]

package com.ocean.exception;

public class Test {

    public static void main(String[] args) {

        int a=10;
        int b=0;
        try {//try 监控区域
            System.out.println(a/b);
        }catch (ArithmeticException e){//catch捕获异常
            System.out.println("程序出现异常，变量b不能为0");
        }finally {//处理善后工作
            System.out.println("finally");
        }
        //finally 可以不要，假设IO，资源，关闭时用
    }
}

try：监控区域
catch：捕获异常，catch(想要捕获的异常类型)，可写多个catch，有一个层层递进，最大的异常写在最下面
finally：处理善后工作，一般可以不用，假设IO、资源、关闭时用
throw、throws: 主动抛出异常，多用于方法中

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EZtxtqos-1620700246735)(E:/note_pictures/JavaSE学习笔记/QQ截图20210511093311.png)]

快捷键：Ctrl+Alt+T，自动生成

System.exit(1),手动结束程序

package com.ocean.exception;

public class Test2 {
    public static void main(String[] args) {
        try {
            new Test2().test(1,0);
        } catch (ArithmeticException e) {
            e.printStackTrace();
        }
    }

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

自定义异常

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3Sl09OmZ-1620700246735)(E:/note_pictures/JavaSE学习笔记/QQ截图20210511094845.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tPqlauq1-1620700246736)(E:/note_pictures/JavaSE学习笔记/QQ截图20210511102243.png)]

"Alt + 回车"万能提示键

撒花完结QAQ

virlorenzxx

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
JavaSE零基础学习笔记

JavaSE零基础学习笔记前言java学习路线博客养成写博客的习惯写CSDN博客，总结自己的学习搭建自己的个人博客网站（可用开源框架去搭建，如WordPress、typecho）DOS命令[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RDoOy1tb-1620700246708)(E:/note_pictures/JavaSE学习笔记/QQ截图20210506105545.png)][外链图片转存失败,源站可能有防盗链机制,建议将图片保
复制链接

扫一扫