Java基础总结

Posted 2021-11-08 Pandafz

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java基础总结相关的知识，希望对你有一定的参考价值。

断断续续五个月，总算把Java基础系统学习了一遍，本节主要是对前面学习的一个总结文。由于本人已经工作，深知基础的重要性，即使工作很忙，也还是挤着时间努力输入。有时觉得坚持很难很难，好在自己还是坚持了过来，不过这只是编程路上跨过的小小一步，前路漫漫，吾将持续求索。

此篇文章为Java基础的一个小结束，是我编程之旅的新起点。
时光不负赶路人，星光不负追梦人，加油！！！

本文已收录于[ 专栏 ]

🌳《Java入门》系列🌳

前言

按照下面分类的知识点，形成一张表格以便时时检验自己的基本功。

1.必备常识概念

1.1 面向对象语言与面向过程语言区别

先举个例子，给定一个业务：Panda飞猪要学会Java并且利用Java语言编程。
面向过程的老师A首先让Panda飞猪第一步看视频做笔记，第二步做题写代码，第三部系统看书写代码来达到Panda飞猪想要的目的。
面向对象的老师B首先让Panda飞猪找所有可以学习Java的工具：书、视频、编程的工具IDEA，接着让Panda飞猪自己利用这些对象达到Panda飞猪想要达到的目的。
可以很明显的看到，面向对象的老师让Panda飞猪找到了对象，但是Panda飞猪还是需要去学习面向过程的老师A的一些方法去真正利用对象达到目的。

面向过程：是一种以过程为中心的编程思想,它是一种基础的顺序的思维方式,面向对象方法的基础实现中也包含面向过程思想。

面向对象：按人们认识客观世界的系统思维方式，采用基于对象（实体）的概念建立模型，模拟客观世界分析、设计、实现软件的办法。通过面向对象的理念使计算机软件系统能与现实世界中的系统一一对应。

面向对象语言是只一切操作都以对象为基础，它是由面向过程语言发展而来的，但正是它的这个特性使得面向对象语言对底层的操作不是很方便。例如：java语言。
面向过程语言是以过程或函数为基础的，这种语言对底层硬件，内存等操作比较方便，但是写代码和调试维护等会很麻烦。例如：c语言。

总结一下哦，有如下几个方面的不同：

出发点不同

面向对象强调把问题直接映射到对象之间的接口上。面向过程强调的过程的抽象化与模块化，以过程为中心，构造、处理世界。

数据处理方式与控制程序方式不同

面向对象，数据与对应的代码封装成一个整体，原则上其他对象不能直接修改其数据，对象的修改只能由自身的完成；面向过程，通过程序处理数据，处理完显示结果，在控制方式上是按照设计调用或返回程序，不能自由导航，各模块之间存在着控制与被控制，调动与被调用的关系。

分析设计与编码转换方式不同

面向对象方法贯穿于软件生命周期的分析，设计及编码中，是一种平滑过程，即实现的是无缝连接。面向过程，强调分析、设计及编码之间按规则进行，实现的是有缝连接。

1.2 类、包、接口、抽象、枚举、函数(方法)、常量、变量名词含义

名称	含义
类	class ：用来描述某一类对象的共同特征
对象	具体的事物、实体
包	Package,可以放很多类
接口	与抽象类相似，是一批类要遵守的规范 interface
抽象	abstract，只声明方法不实现方法
枚举	一组固定的常量组成合法值的类型
函数	用来实现某个功能的方法
常量	final修饰，值不变的量
变量	可被多次改变数值的量

1.3 Java的编译过程,字节码、虚拟机JVM含义

Java源文件由编译器编译成字节码（ByteCode），字节码由java虚拟机（JVM）解释运行。
手动编译Java源代码过程

2.编程语言基础

2.1 变量命名,变量类型，大小驼峰命名方式,常量命名

如下面例子：定义了类、常量、变量、方法

package com.algorithm;

/**
 * @Author: qp
 * @Time: 2021/10/18 21:57
 * @Description　
 */
public class DemoPractice {
    static final float TEST_PI=3.14f;
    final float PI=3.14f;
    float testPi =3.14f;

    @Override
    public String toString() {
        return "DemoPractice{" +
                "TEST_PI=" + TEST_PI +
                ", testPi=" + testPi +
                '}';
    }
}

2.2 变量赋值，基本数据类型、数组、引用类型含义

如下面例子：

package com.algorithm;

import java.util.ArrayList;

/**
 * @Author: qp
 * @Time: 2021/10/18 21:57
 * @Description
 */
public class DemoPractice {
    byte aByte = 1;
    short aShort = 2;
    int anInt = 4;
    long aLong = 8;

    final float TEST_PI = 3.14f;
    float testPi = 3.14f;
    double aDouble = 3.24;
    char aChar = 'c';
    boolean aBoolean=false;

    String string="你好";
    Integer integer1 = new Integer(1);　
}

2.3 算术运算、逻辑运算、位运算

如下面例子：

public class DemoPractice {
    byte aByte = 1;
    short aShort = 2;
    int anInt = 4;
    long aLong = 8;

    final float TEST_PI = 3.14f;
    float testPi = 3.14f;
    double aDouble = 3.24;
    char aChar = 'c';
    boolean aBoolean = false;

    String string = "你好";
    ArrayList arrayList = new ArrayList();
    
    private void math() {
        int i = aByte + aShort;
        i-=aShort;
        i*=aByte;
        i/=aByte;

        long max=(anInt>aLong)?anInt:aLong;
        i=1>>2;
    }
}

2.4 循环、与分支选择

如下面的代码：循环的三种代码实现，选择中嵌套分支结构

public class Demo {

    //while循环
    private static int sum1(int num, int sum) {
        while (num <= 100) {
            sum = sum + num;
            num++;
        }
        return sum;
    }


    //do　while循环
    private static int sum2(int num, int sum) {
        do {
            sum = sum + num;
            num++;

        } while (num <= 100);
        return sum;
    }


    //for循环
    private static int sum3(int num, int sum) {
        for (int i = 1; i <= 100; i++) {
            sum = sum + num;
            num++;
        }
        return sum;
    }

    public static void main(String[] args) {
        int sum = 0;
        int num = 1;
        Scanner scanner = new Scanner(System.in);
        int choice= scanner.nextInt();


        switch (choice){
            case(1):
                System.out.println("第１种求和方式"+sum3(num, sum));
                break;
            case(2):
                System.out.println("第２种求和方式"+sum2(num, sum));
                break;
            case (3):
                System.out.println("第３种求和方式"+sum3(num, sum));
                break;
            default:
                System.out.println("默认求和方式"+sum3(num, sum));
                break;
        }
    }

}

2.5 封装、继承、多态的含义

一篇文章读懂封装、继承、多态，接下来，举个例子说明封装、继承、多态；

import java.beans.DesignMode;
import java.util.Scanner;

/**
 * Math类中封装了2个求和的方法
 */
class Math {
    //while循环
    protected  int sum1(int num, int sum) {
        while (num <= 100) {
            sum = sum + num;
            num++;
        }
        return sum;
    }


    //do　while循环
    protected  int sum2(int num, int sum) {
        do {
            sum = sum + num;
            num++;

        } while (num <= 100);
        return sum;
    }
}


/**
 * Demo继承了Math中所有的非private修饰的方法并且可以重写
 */
public class Demo extends Math{

    /**
     * @param num
     * @param sum
     * @return 重写了求和方法,编译时多态
     */
    @Override
    protected int sum1(int num, int sum) {
        for (int i = 1; i <= 100; i++) {
            sum = sum + num;
            num++;
        }
        return sum;

    }

    public static void main(String[] args) {
            int sum = 0;
            int num = 1;
//向上类型转换,运行时的多态
            Math math = new Demo();
            math.sum1(2,0);
        }
}

3.lang包掌握

3.1 lang包为何不用导入

java.lang包是java语言的核心，它提供了java中的基础类。包括基本Object类、Class类、String类、基本类型的包装类、基本的数学类等等最基本的类。 java.lang包提供利用java编程语言进行程序设计的基础类，它在程序生成时就帮你自动多加了一段程序导入了。

3.2 八大基本类型的对应封装类

java中的数据类型int，double等不是对象，无法通过向上转型获取到Object提供的方法，而像String却可以，只因为String是一个对象而不是一个类型。基本数据类型由于这样的特性，导致无法参与转型，泛型，反射等过程。为了弥补这个缺陷，java提供了包装类。
有8大基本数据类型,其对应的包装类分别为：

类型	字节型	字符型	布尔型	短整型	整型	长整型	单精度实型	双精度实型
基本数据类型名	byte	char	boolean	short	int	long	float	double
包装类名	Byte	Character	Boolean	Short	Integer	Long	Float	Double

3.3 Exception与Error的区别,RuntimeException

Error（错误）：通常是灾难性的致命错误，不是程序（程序猿）可以控制的，如内存耗尽、JVM系统错误、堆栈溢出等。应用程序不应该去处理此类错误，且程序员不应该实现任何Error类的子类。
Exception（异常）：用户可能捕获的异常情况，可以使用针对性的代码进行处理，如：空指针异常、网络连接中断、数组下标越界等。
RuntimeException类及其子类称为非检查型异常，Java编译器会自动按照异常产生的原因引发相应类型的异常，程序中可以选择捕获处理也可以不处理，虽然Java编译器不会检查运行时异常，但是也可以去进行捕获和抛出处理。RuntimeException类和子类以及Error类都是非受检异常。

3.4 Object

Object类是Javajava.lang包下的核心类，Object类是所有类的父类，何一个类时候如果没有明确的继承一个父类的话，那么它就是Object的子类；
Object 类属于java.lang包，此包下的所有类在使用时无需手动导入，系统会在程序编译期间自动导入

3.5 Number与Math

Math类定义了基本数学运算的属性和方法，所有方法都为static，可以通过math类在主函数直接调用。
所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类；

public class Demo1 {

    public static void main(String[] args) {
//        实现小数四舍五入
        Double aDouble = new Double(1.73);
        System.out.println(Math.round(aDouble));
    }
}

3.6 System

System类代表系统，系统级的很多属性和控制方法都放置在该类的内部。该类位于java.lang包。
由于该类的构造方法是private的，所以无法创建该类的对象，也就是无法实例化该类。其内部的成员方法和成员变量都是static（静态）的，所以也可以很方便的调用他。


public class Demo1 {

    private static final String TAG ="Demo1" ;

    public static void main(String[] args) {
//        打印当前时间毫米值
        System.out.println(System.currentTimeMillis());
//        复制数组
        int[] i = {1, 2, 3};
        int[] j = new int[5];
        System.arraycopy(i, 0, j, 2, 3);
    }
}

4. String

4.1 String 与char的关系

字符串效果相当于数组（char[]），char是一个可以用来存储字符数据的变量类型，而string就是一个存储一串字符数据的变量类型，他们的共同点就是他们都是变量类型，都是用来存储字符的
字符串String是引用数据类型，char是基本数据类型

4.2 字符串查找出所在位置下标

String str ="hello word";
char c1 = str.charAt(0);//c1的值为'h'
char c2 = str.chatAt(6);//c1的值为'w'

4.3 字符串截取

String str1 = "我每天学习";
String str2 = str1.substring(1);//str1="每天学习"
String str3 = str1.substring(0,3)//str2="我每天"

4.4 字符串替换

 String string = new String("hello");
 String str = string.replaceAll("h", "y");//str =yello

4.5 字符串拼接

String s1 = "I am";
String s2 = " a student";
String s3 = s1 + s2;
String s4 = s1.concat(s2);
int s5 = s1.concat(s2)
System.out.println(s3);
System.out.println(s4);
System.out.println("s3=s4:"+(s3==s4));//字1符串连接逻辑异常

4.6 切割成多个字符串

String str="1234@abc";
String[] a = str.split("@");
System.out.println("处理结果: "+a[0]+","+a[1]);   //输出的是: 处理结果: 1234,abc

4.7 StringBuilder与StringBuffer

String类是不可变类，任何对String的改变都会引发新的String对象的生成；
StringBuffer是可变类，任何对它所指代的字符串的改变都不会产生新的对象，线程安全的。
StringBuilder是可变类，线性不安全的，不支持并发操作，不适合多线程中使用，但其在单线程中的性能比StringBuffer高。

StringBuffer strBuf = new StringBuffer("abc");
String str = strBuf.append("def");//str = "abcdef"
StringBuilder bu1 = new StringBuilder();
System.out.println("bu1"+bu1);// bu1
StringBuilder bu2 = new StringBuilder("abc");
System.out.println("bu2:"+bu2);// bu2:abc

5. 容器(集合)

5.1 List

List集合,有两种实现类：ArrayList、LinkedList。
ArrayList和数组类似，顺序排列，访问速度快，插入和删除速度块较慢

LinkedList，采用链表数据结构，访问速度慢，插入和删除速度块

class Example8_5{
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add("a");
        arrayList.add("b");
        arrayList.add("c");
        System.out.println("arrayList的元素为："+arrayList);
        arrayList.set(0,"c");//将索引为０的位置对象a修改为对象c
        System.out.println("arrayList的元素为"+arrayList);
        arrayList.add(1,"e");//将对象e添加到索引为１的位置
        System.out.print("arrayList的元素为:");
        for (int i=0;i<arrayList.size();i++){
            System.out.print(arrayList.get(i));//for循环迭代arrayList集合元素
        }
        System.out.println("");
        System.out.println("arrayList指定元素c位置的索引为"+arrayList.indexOf("c"));//返回列表中指定元素c位置的索引
        System.out.println("arrayList指定元素c最后位置的索引为"+arrayList.lastIndexOf("c"));//返回列表中指定元素c最后位置的索引
        System.out.println("arrayList的指定区域为"+arrayList.subList(1,2));//返回列表中指返回一个指定区域的List集合对象[1,2)

        LinkedList linkedList = new LinkedList();
        linkedList.add("a");
        linkedList.add("b");
        linkedList.add("c");
        linkedList.add("d");
        //获得并输入列表开头的对象
        System.out.println("列表开头元素为："+linkedList.getFirst()+"列表结尾元素为："+linkedList.getLast());

        linkedList.addFirst("rr");//向列表开头添加一个对象
        System.out.println("列表中所有元素："+linkedList);
        linkedList.removeLast();//移除列表结尾元素
        System.out.println("列表结尾元素为："+linkedList.getLast());//获取并输出列表结尾的对象
    }
}