超详细Java学习知识点-不定更新

练气期

一、了解

jvm就是Java虚拟机 通过这个进行编译 可以实现跨平台

jre包括jvm和运行java的核心库

jdk包含jre和开发工具：javac.exe 和 java.exe

二、开始helloword

关键字

常量:整数、字符串、小数、字符、布尔值、空

三、数据类型

计算机储存单元：最小位信息单元 bit 最小的存储单元 byte 1byte = 8bit

是强类型语言 不同的数据类型分配了不同的存储空间 相比之下 js的数据类型是弱类型语言

Java数据类型 ：

 

内存：

变量申明的空间在内存中 ，程序的运行也是在内存中

long类型：

后面+L

float类型：

后面+F

四、标识符

就是命名规则！have  数字开头、驼峰命名法 （小驼峰变量和方法、大的是类）、不能是关键字

五、类型转换

自动类型转换：由小到大

强制类型转换：

比如：int a = (int)123.123

六、算数运算符

加减乘除余数

注意：两个整数相除得到的整数 要得到小数必须有浮点数的参与

加操作会自动提升

七、赋值运算符

八、自增自减运算符

九、关系运算符

十、逻辑运算符

&  有false 则false

|  有true则true  

^ 有相同则false 有不同则true（异同）

！非

十一、短路运算符

 && || 和& | 基本相同 但是 有个短路的效果

十二、三元运算符

a>b?a:b

十三、数据输入

Scanner（扫描器）

使用一共 三步：

导包：import java.util.Scanner

创建对象：Scanner sc = new Scanner(System.in)

接收数据：int x = sc.nextInt()

十四、流程控制

if（）| if（）else（）|  if   else if  else

switch（）{ case ：break  ，default  } 这个可以多判断   case1: case2: case3:

for循环：水仙花数 ：每位的立方和等于原数

while  do……while

十五、 跳出控制语句

contiune 跳出本次循环体的内容

break 终止循环

十六、嵌套循环

十七、Random

产生一个随机数

使用三步骤：

导包：import java.util Random

创建对象：Random  r = new Random()

获取随机数： int number = r.nextInt(10) //范围【0.10）

十八、数组

存储多个类型的数据

格式一：int arr[]

格式二： int[] arr

使用：int[] arr = new int[3]

十九、java内存分配

 

左边的是栈内存，右边的是堆内存

栈内存：存储局部变量。用完就消失

堆内存：存储new出来的内容（实体和对象）

 

二十、数据初始化之静态初始化

int[] arr = new int[]{1,2,3}

 

 简化版：int[ ] arr = {1,2,3}

--------------2021-11-7-----------------------

二十一、遍历

简单~~~~

二十二、方法

解释：将具有独有功能的代码块组织成为一个整体，使其具有特殊功能的代码集。

步骤：先创建（方法定义）、再调用（手动执行）。

注意：方法是平级关系，不能嵌套；
　　　void 表示无返回值，可以省略return，也可以单独的书写return ，但是后面不能加数据，后面加数据就要去除void，写上数据类型。

 二十三、带返回值方法的定义和调用

public class demo1 {
    /**
     *  带返回值方法的定义和调用
     *  定义格式:
     *      public static 数据类型 方法名(参数）{
     *          return 数据;
     *  }
     * 调用格式:
     *     数据类型 变量名 = 方法名(参数)
     * 
     * */
    public static void main(String[] args) {
        // 调用方法
        boolean flag =  isEvenNumber(10);
        System.out.println(flag);
    }
        //创建一个方法 判断一个数是否偶数
    public static boolean isEvenNumber(int num) {
        if(num % 2 == 0) {
        return true;
        } else {
        return false;
        }
    }

}

二十四、方法重载

多个方法：1.同一个类中；
　　　　　2.相同的方法名；

　　　　　3.参数不同，类型不同，数量不同。

在调用的时候,java虚拟机会通过参数的不同来区分同名的方法。

eg:

public class demo02 {
    public static void main(String[] args) {
        // 调用方法
        System.out.println(compare(10, 20));
        System.out.println(compare((byte)10,(byte)20));
        System.out.println(compare((short)10,(short)20));
        System.out.println(compare(10L, 20L));
    }
        //创建一个方法 判断两数相等
    public static boolean compare(int a,int b) {
        System.out.println("int");
        return a == b;
    }
    public static boolean compare(byte a,byte b) {
        System.out.println("byte");
        return a == b;
    }
    public static boolean compare(short a,short b) {
        System.out.println("short");
        return a == b;
    }
    public static boolean compare(long a,long b) {
        System.out.println("long");
        return a == b;
    }
}

二十五、方法参数传递（基本类型）

 eg：

public class demo03 {
    public static void main(String arg[]) {
        int number  = 100;
        System.out.println("调用change方法前：" + number);  // number = 100
        change(number);                                    // 栈内存中开辟了另一个方法 里面有个新的number
        System.out.println("调用change方法后：" + number);  // 这是main方法中的number，依然number = 100
    }
    public static void change(int number) { 
        number = 200;
    }
}

总结：对于基本数据类型的参数，形式参数的改变，不影响实际参数的值。

二十六、方法参数传递（引用类型）

eg：

public class demo03 {
    public static void main(String arg[]) {
        int[] arr  = {10,20,30};
        System.out.println("调用change方法前：" + arr[1]);  // arr[1] = 10
        change(arr);                                        // 直接改变了堆内存中arr对应的地址的arr[1]的值
        System.out.println("调用change方法后：" + arr[1]);  // 改变后 arr[1] = 200
    }
    public static void change(int[] arr) { 
        arr[1] = 200;
    }
}

二十七、数组遍历

简单~~~~直接悟通！

二十八、Debug（断点调试用来调试程序）多用

二十九、导包键盘录入

import java.util.Scanner;  //导入对应的包
// 快捷键 ALT+ENTER

public class demo04 {
    public static void main(String arg[]) {
        //键盘录入一个数
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数：");
        int number = sc.nextInt();
    }
}

 筑基期

一、面向对象

对象：客观存在的事物皆为对象（没对象就new一个吧，同志们），比如：小红的华为手机；

面向对象：关注对象，了解详细信息，面对具体的对象操作；

类：类是对象的数据类型，是具有相同属性和行为的一组对象的集合 ，比如：人；

　　属性：对象特有的东西，比如：名字，年龄；

　　行为：对象的功能操作，比如：打球，跑步；

二、java中类的定义

类的重要性：是java程序的基本组成单位；

类的组成：属性和行为；

　　属性：在类中通过成员变量来体现（类中方法外的变量）；

　　行为：在类中通过成员方法来体现（和前面的方法相比去掉static关键词即可）；

eg：

public class phone {
    // phone 的成员变量 就是属性
    String brand;
    int price;
    
    //成员方法 
    public void call() {
        System.out.println("打电话");
    }
    public void sendMessages() {
        System.out.println("发短信");
    }
}

三、对象的使用

格式： 类名 对象名 = new 类名（）；

　　　Phone p = new Phone( )；

eg:

// 新建一个测试类 使用上面的 对象类
public class PhoneDemo {
    public static void main(String arg[]) {
        //创建对象
        phone p = new phone();
        
        //使用成员变量
        
        System.out.println(p.brand);
        System.out.println(p.price);
        
        p.brand = "小米";
        p.price = 2000;
        
        System.out.println(p.brand);
        System.out.println(p.price);
        //使用成员方法
        
        p.call();
        p.sendMessages();
    }
}

四、对象的内存图（执行流程）

 

如果多次new，那么在堆内存中也会多出新的对象，相应不同的地址。

简单易懂，我悟了。

五、成员变量和局部变量

 

 

 

 

 四大不同：

　　一位置不同：如图；

　　二内存中位置不同：成员在堆内存，局部在栈内存；

　　三生命周期不同：成员随着对象的存在而存在，局部随着方法的存在而存在；

　　四初始化不同：成员有默认的初始化值，局部没有默认值并且必须先定义才能使用；

六、封装

6.1、private关键字

是一个权限修饰符；

可以修饰成员变量和成员方法；

作用：保护成员不被别的类使用，只能 在本类中才能访问；

　　   但是如果需要被其他类使用，提供两个方法：

　　　　　get变量名（）方法，用于获取成员变量的值；（方法用public 修饰）

　　　　　set变量名（）方法，用于设置成员变量的值；（方法用public 修饰）

6.2、this关键字

局部变量 赋值给 成员变量 但是局部变量和成员变量同名 就使用 this

public class phone {
    // phone 的成员变量 就是属性
    String brand;
    int price;
    
    //成员方法 
    public void call() {
        System.out.println("打电话");
    }
    public void sendMessages() {
        System.out.println("发短信");
    }
    public String getBrand() {
        return brand;
    }
    public void setBrand(String brand) {
        this.brand = brand;   // 为了让局部变量 赋值给 成员变量 就使用 this
    }
    public int getPrice() {
        return price;
    }
    public void setPrice(int price) {
        this.price = price;
    }
}

6.3、this的内存原理

 

就一句话，谁调用，this就是指的那个对象地址。

6.4、封装

是面向对象的三大特征之一（封装、继承、多态）

 好处：可以控制成员变量的操作，提高安全性；

　　　 提高代码的复用性；

七、构造方法

构造方法是一个特殊的方法；

作用：创建对象；

格式：

public class 类名{
        修饰符 类名（参数）{  // 修饰符一般public
            
        }
    }

功能：主要完成对象数据的初始化；

注意：如果类中没有构造方法，那么就会系统默认创建一个无参构造方法；有构造方法，那么就不会提供默认的构造方法；

八、标准类制作

要求：

1、成员变量

　　使用private修饰；

2、构造方法

　　提供一个无参构造方法；

　　提供一个带多个参数的构造方法；

3、成员方法

　　提供一个成员变量对应的setXxxx（）/getXxxx（）；

　　提供一个显示对象信息的show（）；

4、创建对象并为其成员变量赋值的两种方式

　　无参构造方法创建对象后使用setXxxx（）赋值；

　　使用带参构造方法直接创建带有属性值得对象；

eg:

标准类

public class Student {
    // 成员变量
    private String name;
    private int age;
    
    // 构造方法
    public Student() {}  // 无参构造
    public Student(String name,int age) { // 有参构造
        this.name = name;
        this.age = age;
    }
    
    //    成员方法
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return age;
    }
    
    // show 方法
    public void show() {
        System.out.println(name + "," + age);
    }
}

 测试类：

public class StudentDemo {

    public static void main(String[] args) {
        // 无参构造方法创建对象后用set赋值
        Student s1 = new Student();
        s1.setName("彭于晏");
        s1.setAge(18);
        s1.show();
        // 多个参数构造方法直接创建带属性值的对象
        Student s2= new Student("胡歌",20);
        s2.show();
    }

}

九、字符串

9.1、API

java api 就是jdk提供的各种功能的java类。eg：Scanner。

9.2 、String

在java.lang下，使用时是不用导包的。

String 代表字符串，java程序中所有的双引号字符串，都是String对象。

特点：

　　字符串不可变，他们的值在创建后不能被更改；

　　虽然String值不可变，但是他们可以被共享；

　　字符串效果相当于字符数组（chart【】），但是底层原理是字节数组byte【】

题外话：jdk8及以前是字符串数组，jdk9级以后是字节数组。

9.3、String类的构造方法

对象特点：

　　每次new都有一个新地址；

　　以“ ”方式给出的字符串，只要字符的序列相同（顺序和大小写），无论在程序代码中出现几次，jvm都只会创建一个String对象，并在字符串池中维护。

9.4、字符串的比较

以前 使用 == 比较：

　　基本类型：比较的是数值是否相同；

　　引用类型：比较的是地址是否相同；

字符串想要比较数值是否相同：

　　一个新方法 equals（）

　　eg:(s1.equals(s2))

--------------2021-11-17-----------------------

十、StringBuilder

意义：如果对字符串进行拼接，每次拼接都会构建一个新的String对象，即耗时，也耗内存空间，Stringbuilder类就是来解决这问题。

区别：

　　String是不可变的；

　　StringBulider是可变的；

方法：

StringBuilder sb = new StringBuilder();
   //添加数据 返回的是对象本身
sb.append("hello");
   // 翻转
sb.reverse();

StringBuilder和String的相互转换：

StringBuilder sb= new StringBuilder();
// StringBuilder To String
String s = sb.toString();
// String To StringBuilder
String s = "hello"
StringBuilder sb =new StringBuilder(s)

十一、集合

意义：当我们存储数据的时候会选择数组，但是数组长度是固定的，不一定会满足我们的需求，更适应不了变化的需求，这时候就有集合。

特点：存储空间可变的数据模型。

ArrayList<E>:
            //可以调整大小的数据实现。
            // <E>是一种特殊的数据类型，泛型。
　　//怎么用？
    E替换我们所应用数据类型
    eg：ArrayList（String）

方法：添加add、删除remove、修改set、获取get、集合长度size

eg：
public static void main(String arg[]){
         ArrayList<String> array = new ArrayLisy<String>();
         // 添加 add
         array.add("hello");
         // 指定位置 插入元素
         array.add(1,javase);
　　　　　 // 删除 可以通过索引删除 
　　　　　 array.remove(1); 
　　　　　// 修改 
　　　　　array.set(1,"ashduj");
　　　　　// 获得
　　　　　array.get(0);
　　　　　// 长度
　　　　　array.size();

}             

十二、来个学生管理系统来总结练手

学生类:

package com.learnjava.Student;
/**
 * 
 * 学生类
 *
 */
public class Student {
    // 学号 
    private String sid;
    // 姓名
    private String name;
    // 年龄
    private String age;
    // 居住地
    private String address;
    
    // 无参构造函数Student
    public Student() {
        
    }
    // 有参构造函数Student
    public Student(String sid,String name, String age,String address) {
        this.sid = sid;
        this.name = name;
        this.age = age;
        this.address = address;
    }
    public String getSid() {
        return sid;
    }
    public void setSid(String sid) {
        this.sid = sid;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAge() {
        return age;
    }
    public void setAge(String age) {
        this.age = age;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    
}

学生管理类：

package com.learnjava.Student;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.Scanner;

/**
 * 
 * 学生管理系统
 *
 */

public class StudentManger {
    /*
     * 1.用输出语句完成主界面的编写;
     * 2.用Scanner实现键盘的输入;
     * 3.用switch语句完成操作的选择;
     * 4.用循环完成再次回到主界面;
     */

    public static void main(String[] args) {
        // 创建集合对象，用于存储学生数据
        ArrayList<Student> array = new ArrayList<Student>();
        // 用循环完成再次回到主界面 无限循环
        while(true) {
        // 用输出语句完成主界面的编写;
        System.out.println("-----------欢迎来到学生管理系统-----------");
        System.out.println("1.添加学生");
        System.out.println("2.删除学生");
        System.out.println("3.修改学生");
        System.out.println("4.查看所有学生");
        System.out.println("5.退出");
        System.out.println("请输入你的选择:");
        
        // 用Scanner实现键盘的输入
        Scanner sc = new Scanner(System.in);
        String line = sc.nextLine();
        
        // 用switch语句完成操作的选择
        
        switch(line) {
        case "1":
//            System.out.println("添加学生");
            addStudent(array);
            break;
        case "2":
//            System.out.println("删除学生");
            removeStudent(array);
            break;
        case "3":
//            System.out.println("修改学生");
            setStudent(array);
            break;
        case "4":
//            System.out.println("查看所有学生");
            findAllStudent(array);
            break;
        case "5":
            System.out.println("谢谢使用");
            System.exit(0); // jvm 虚拟机 退出
        }
        
        }
        
    }

    // 定义一个方法,添加学生方法
    public static void addStudent(ArrayList<Student> array) {

        // 键盘录入学生对象需要的数据,显示提示信息，提示输入何种信息；
        String sid;
        Scanner sc =new Scanner(System.in);
        while(true) {
            System.out.println("请输入学生学号：");
             sid = sc.nextLine();
            
            boolean flag  = isUsed(array, sid);
            if(flag) {
                System.out.println("学号被使用，请重新输入");
            }else {
                break;
            }
        }
        
        System.out.println("请输入学生姓名：");
        String name = sc.nextLine();
        System.out.println("请输入学生年龄：");
        String age = sc.nextLine();
        System.out.println("请输入学生居住地：");
        String address = sc.nextLine();
        
        // 创建学生对象，把输入的内容赋值给学生对象的成员变量
        Student s = new Student();
        s.setSid(sid);
        s.setName(name);
        s.setAge(age);
        s.setAddress(address);
        
        // 将学生对象添加到集合中；
        array.add(s);
        
    }

    // 定义一个方法，判断学号是否被使用
    public static boolean isUsed(ArrayList<Student> array ,String sid) {
        // 如果与集合中某个学生学号相同，则返回true，否则返回false；
        boolean flag = false;
        for(int i = 0; i < array.size();i++) {
            Student s = array.get(i);
            if(s.getSid().equals(sid)) {
                flag = true;
            }else {
                flag =false;
            }
        }
        return flag;
    }
    // 定义一个方法,用于查询学生信息
    public static void findAllStudent(ArrayList<Student> array) {
        // 判读集合中是否有数据，从而提示,不显示表格
        if(array.size() == 0) {
            System.out.println("无数据,请添加数据!");
            return;
        }
        //显示表头
        System.out.println("学号\t\t\t姓名\t\t年龄\t\t居住地");
        
        // 遍历集合 显示学生信息 年龄显示 “岁”
        
        for(int i = 0 ; i < array.size(); i++) {
            Student s = array.get(i);
            System.out.println(s.getSid()+"\t\t"+s.getName()+"\t\t"+s.getAge()+"\t\t"+s.getAddress());
        }
    }

    // 定义一个方法,用于删除学生信息
    public static void removeStudent(ArrayList<Student> array) {
        // 键盘录入要删除学生的学号，显示提示信息
        Scanner sc = new Scanner(System.in);
        
        System.out.println("请输入你要删除学生的学号：");
        
        String sid = sc.nextLine();
        int index = -1;
        //遍历集合 删除对应学生对象
        for(int i = 0 ; i < array.size() ; i++) {
            Student s = array.get(i);
            if(s.getSid().equals(sid)) {
                index = i;
                break;
            }
        }
        if(index == -1) {
            System.out.println("为找到相关信息，请重新输入！");
        }else {
            array.remove(index);
            System.out.println("删除学生成功！");
        }
        
    }
    
    // 定义一个方法,用于修改学生信息
    public static void setStudent(ArrayList<Student> array) {
        // 键盘录入要修改的学生的学号，显示提示信息
        Scanner sc = new Scanner(System.in);
        
        System.out.println("请输入你要修改学生信息的学号：");
        String sid = sc.nextLine();
        int index = -1;
        for(int i = 0; i < array.size();i++) {
            Student student = array.get(i);
            if(student.getSid().equals(sid)) {
                index = i;
                break;
            }
        }
        if(index == -1) {
            System.out.println("为找到相关信息！请重新输入！");
            return;
        }
        //键盘输入要修改的内容
        System.out.println("请输入学生的新名字：");
        String name = sc.nextLine();
        System.out.println("请输入学生的新年龄：");
        String age = sc.nextLine();
        System.out.println("请输入学生的新地址：");
        String address = sc.nextLine();
        
        // 创建学生对象
        Student  s = new Student();
        s.setSid(sid);
        s.setName(name);
        s.setAge(age);
        s.setAddress(address);
        
        // 遍历集合修改对应信息
        
        array.set(index, s);
        System.out.println("修改学生成功！");
    }
}

修炼完成！ 内力大增！

十三、继承

格式：public class 子类名 extends 父类名{ }；

父类：被称为基类、超类；

子类：被称为派生类；

话不多说直接敲代码：

package com.learnjava.jicheng;
/*
 * 父类
 */
public class Fu {
    public void show() {
        System.out.println("show方法被调用!");
    }
}



package com.learnjava.jicheng;
/*
 * 子类继承父类
 */
public class Zi extends Fu {
    public void method() {
        System.out.println("method方法被调用");
    }
}


package com.learnjava.jicheng;
/*
 *测试类
 */
public class testDemo {
    public static void main(String[] arg) {
        // 创建对象 ，调用方法
        Fu f = new Fu();
        f.show();
        Zi z = new Zi();
        z.method();
        z.show();
    }
}

总结：子类继承有父类的内容，也有自己的内容。

好处：提高了代码的复用性（多个类相同的内容可以放在同一个类中）；

　　　提高代码维护性（只用修改一处就行了）；

坏处：让类与类之间产生了关系，增加了耦合性，当父类变化后子类不得不变化，削弱了子类的独立性。

什么时候使用继承？

答：当两个类，满足A是B的一种，或者B是A的一种，就可以用。

十四、继承中变量的访问特点

变量查找：

　　① 子类局部变量找；

　　② 子类成员变量找；

　　③ 子类成员变量找；

　　④ 没有就报错；

十五、super

 super 关键词的用法和this关键词的用法相似

　　~ this：代表本类对象的引用；

　　~ super ：代表父类存储空间的标识（可以理解为父类对象的引用）；

除了成员变量还可以访问：this(…)/super(…)访问构造方法，this.成员方法（…）/super.成员方法（…）访问成员方法。

十六、继承中构造方法的访问特点

注意：一般子类构造方法中都有一个看不见的super（），指向的是父类的无参构造方法；

　　　　若父类没有无参构造方法，那么就super（xxx）调用有参构造方法；

推荐父类自己给出无参构造方法；

十七、继承中成员方法的访问特点

先在子类成员范围中找；

再到父类成员范围中找；

没有就报错；

十八、super的内存图

 

十九、方法重写

概述：子类中出现了和父类中一模一样的方法声明。

应用：子类需要父类的功能，而功能主体子类有自己特有内容是，可以重写父类中的方法，这样，及沿袭了父类的功能，又定义了子类特有的内容。

eg：

package com.learnjava.overwrite;
/**
 * 
 * 旧手机
 *
 */
public class Phone {
    public void call(String name) {
        System.out.println("给"+ name + "打电话");
    }
    
}


package com.learnjava.overwrite;
/***
 * 
 *     新手机
 *
 */
public class newPhone extends Phone {
    @Override
    public void call(String name) {
        System.out.println("开启视频功能");
        super.call(name);
    }
}




package com.learnjava.overwrite;
/***
 * 
 * 测试类
 *
 */
public class PhoneDemo {
    public static void main(String[] arg) {
        // 创建对象 调用方法
        Phone p = new Phone();
        p.call("周杰伦");
        System.out.println("-----------");
        
        newPhone np = new newPhone();
        np.call("林俊杰");
    }

}

学习到一个注解：Override 检查重写方法的方法声明的正确性。

注意事项：

　　父类的私有方法不能重写（子类没法继承）（就是 private声明的方法）；

　　子类方法访问权限不能更低（public >  默认 > 私有）；

二十、Java中继承的注意事项

· Java 中类只支持单继承，不支持多继承；

· Java 中类支持多层继承；

--------------2021-11-19-----------------------

二十一、修饰符

权限修饰符（私有、默认、保护、公共）

 

final修饰符（最终态）

变量是基本类型：数值不变

变量是引用类型：地址不变，但是地址中的内容可以改变

static（静态）

描述：被修饰的类的对象进行共享；

调用：可以通过对象调用，也可以通过类名调用（推荐类名）；

访问特点：非静态的成员方法能访问 非静态/静态的成员变量和成员方法；但是静态的成员方法只能访问静态的；

二十二、多态

概述：同一个对象，在不同时刻表现出来的不同形态。

--------------2021-11-22-----------------------

 金丹期

暂无此阶段修为

 元婴期

 暂无此阶段修为

 化神期

 暂无此阶段修为

 大乘期

 暂无此阶段修为

 

 每日更新中…………