Java基础知识回顾+扫盲

最新推荐文章于 2024-07-21 16:01:09 发布

每天进步一點點

最新推荐文章于 2024-07-21 16:01:09 发布

阅读量464

点赞数

分类专栏： Java学习

本文链接：https://blog.csdn.net/DDDDeng_/article/details/106710474

版权

Java学习专栏收录该内容

30 篇文章 3 订阅

订阅专栏

JAVA基础知识扫盲ing…

基础语法

一、注释

//                            _ooOoo_    
//                           o8888888o    
//                           88" . "88    
//                           (| -_- |)    
//                            O\ = /O    
//                        ____/`---'\____    
//                      .   ' \\| |// `.    
//                       / \\||| : |||// \    
//                     / _||||| -:- |||||- \    
//                       | | \\\ - /// | |    
//                     | \_| ''\---/'' | |    
//                      \ .-\__ `-` ___/-. /    
//                   ___`. .' /--.--\ `. . __    
//                ."" '< `.___\_<|>_/___.' >'"".    
//               | | : `- \`.;`\ _ /`;.`/ - ` : | |    
//                 \ \ `-. \_ __\ /__ _/ .-` / /    
//         ======`-.____`-.___\_____/___.-`____.-'======    
//                            `=---='    
//    
//         .............................................    
//                  佛祖保佑             永无BUG

二、变量和常量

1、变量

类变量
实例变量

从属于对象，如果不自行初始化，这个类型的默认值 0 null
局部变量

必须声明和初始化值

2、常量

常量(Constant)：初始化后不能改变值，不会变动的值。所谓常量就可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。

final double PI = 3.14;

常量名一般使用大写字符；

三、JavaDoc生成文档

javadoc命令是用来生成自己API文档的
参数信息
- @author 作者名
- @version 版本号
- @since 指明需要最早使用的jdk版本
- @param 参数名
- @return 返回值情况
- @throws 异常抛出情况
```
/**
 * @author Danial
 * @version 1.0
 * @since 1.8
 */
 public class Demo1 {
     
 }
```
1、执行命令：javac -encoding UTF-8 -charset UTF-8 Demo1.java 自动生成帮助文档；

2、使用使用Intellij Idea生成JavaDoc文档

四、用户交互Scanner

next()
- 一定要读取到有效字符后才可以结束输入；
- 对输入有效字符之前遇到的空白，next()方法会自动将其去掉；
- 只有输入有效字符串后才将其后面输入的空白作为分隔符号或者结束符。
- next()不能得到带有空格的字符串；
nextLine()
- 以Enter为结束符，也就是说nextLine()方法返回的是输入回车之前的所有字符；
- 可以获得空白；

五、流程控制

switch多选择结构

switch case语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。

switch语句中的变量类型可以是：

byte、short、int或者char

从Java SE7 开始，switch支持字符串String类型了,同时case标签必须为字符串常量或字面量

/*测试switch对字符串的支持
  底层通过比较name的HashCode实现
 */
public class SwitchDemo {
    public static void main(String[] args) {
        String name = "Daniel";

        switch (name){
            case "Daniel":
                System.out.println("He is Daniel");
                break;
            case "Fan":
                System.out.println("He is Fan");
                break;
        }
    }
}

While 和 do-While的区别

while先判断后执行，dowhile先执行后判断；

dowhile总是保证循环体至少被执行一次；

//输出三角形
public class TrangleDemo {

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

六、Java方法

1、方法的重载

重载就是在一个类中，有相同的函数名称，但形参不同的函数；
方法的重载规则:
- 方法名称必须相同；
- 参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）
- 方法的返回类型也可以相同也可以不同
- 仅仅返回类型不同不足以成为方法的重载
实现原理

方法名称相同时，汇编器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。

2、可变参数

从JDK1.5开始，Java支持传递同类型的可变参数给一个方法。
在方法声明中，在指定参数类型后加一个省略号（…）。
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。

    public static void printMax(double... numbers){
        if(numbers.length==0){
            System.out.println("No argument passed");
            return;
        }

        double result = numbers[0];

        for(int i = 1; i < numbers.length; i++){
            if (numbers[i] > result){
                result = numbers[i];
            }
        }
        System.out.println("The max value is " + result);
    }

3、递归

递归就是：A方法调用A方法，就是自己调用自己。

递归结构包括两个部分：

- 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。
- 什么时候需要调用自身方法。

// 递归思想
public class RecursiveTest {
    public static void main(String[] args) {
        int result = f(5);
        System.out.println(result);
    }

    // 利用递归求阶乘
    public static int f(int num){

        if (num==1){
            return num;
        }else {
            return num*f(num - 1);
        }
    }
}

七、数组

1、声明和创建

int[] nums = new int[10];
//1.声明一个数组
int[] nums;
//2.创建一个数组
nums = new int[10];

2、三种初始化方式

静态初始化

//静态初始化：创建 + 赋值
int[] a = {1,2,3,4,5}；

动态初始化

//动态初始化：包含默认初始化
int[] b = new int[10];
b[0] = 10;

默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

3、冒泡排序

思路:大数往后沉 / 小数往后移

    //冒泡排序
    public static int[] bubbleSort(int[] arr) {

        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        return arr;
    }

4、稀疏数组

当一个数组中大部分元素为0，或者为同一值得数组时，可以使用稀疏数组来保存该数组。
稀疏数组的处理方式是：
- 记录数组一共有几行几列，有多少不同值；
- 把具有不同值得元素和行列及值记录在一个小规模数组中，从而缩小程序的规模；
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gkBxsUbF-1591928627320)(C:\Users\邓联庆\AppData\Roaming\Typora\typora-user-images\image-20200609225956449.png)]

八、面向对象

面向对象编程的本质是：以类的方式组织代码，以对象的形式组织（封装）数据。

1、构造器

构造器
1. 和类名相同；
2. 没有返回值；
作用
1. new（）本质是在调用构造方法；
2. 初始化对象的值；
注意点

定义有参构造之后，如果想使用无参构造，>要显式的定义一个无参的构造。

2、创建对象内存分析

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-N3qyyqwg-1591928627323)(C:\Users\邓联庆\AppData\Roaming\Typora\typora-user-images\image-20200610121651874.png)]$

3、封装

属性私有，get / set

提高程序的安全性，保护数据；
隐藏代码的实现细节；
统一接口；
系统可维护性增加了；

4、Super详解

super注意点
1. super调用父类的构造方法，必须在构造方法第一行；
2. super只能出现在子类的方法或者构造方法中；
3. super和this不能同时调用构造方法；
和 this 对比
1. 代表的对象不同
  - this : 本身调用者这个对象
  - super : 代表父类对象的引用
2. 前提
  - this : 没有继承也可以使用
  - super : 只能在继承的条件才可以使用
3. 构造方法
  - this() ; 本类的构造
  - super() : 父类的构造

5、继承 -方法重写

重写：需要有继承关系，子类重写父类的方法！

方法名必须相同
参数列表必须相同
修饰符：范围可以扩大但不能缩小： public > Protected > Default > private
抛出的异常：范围，可以被缩小，但不能扩大；

重写，子类的方法和父类必须要一致；方法体不同！

为什么要重写：

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

6、多态

public static void main(String[] args){
   	/*
   	 一个对象的实际类型是确定的
   	 可以指向的引用类型就不确定了：父类的引用指向子类
   	*/
    
    // Student能调用的方法都是自己的或者继承父类的
    Student s1 = new Student();
    //Person父类型，可以指向子类，但是不能调用子类独有的方法
    Person s2 = new Student();
    Object s3 = new Student();
    
    //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！
}

多态注意事项：

多态是方法的多态，属性没有多态
父类和子类，有联系
存在条件：继承关系，方法需要重写(若子类重写了父类的方法，则执行子类的方法)，父类引用指向子类对象！Father f1 = new Son();

多态规则：

若子类重写了父类的方法，则执行子类的方法

若子类没有重写父类的方法，则按照左边的引用类型调用方法；

public class Person {

    private String name = "Father";
    
    public void run(){
        System.out.println("i am your father , i can't run fast");
    }
}

public class Son extends Person{
    @Override
    public void run() {
        System.out.println("i am your son");
    }
}

public class Application {
    public static void main(String[] args) {
        Person p1 = new Person();
        Person p2 = new Son();

        p1.run();
        p2.run();
    }
}