本文主要是介绍JAVA基础基础知识总结，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

一、变量和数据类型

       一，.变量--- 数据类型 变量名=值;

             变量名：----命名规则
                 1. 由字母 数字 下划线_  美元符 $ 组成
                 2. 不能以数字开头
                 3. 不能使用java的关键字。
                 4. 习惯: 见名知意  类名接口名每个单词首字母大写。
                             方法 变量名第一个单词的首字母小写其他单词的首字母大写.[studentAge]
                             常量所有字母全大写。

       二，1.基本数据类型

                整型类型： byte[1字节] short[2字节] int[4字节] long[8字节]

                浮点类型：float[4字节] double[8字节]

                字符型   ： char[2个字节]

                布尔类型：boolean[1字节]

                2.引用数据类型

                类（class），接口（interface），枚举（enum），注解（annotation），数组，String

二 、Java流程控制

        一，分支结构（分支结构主要控制代码是否执行 ）

         if(条件){}
         
         if(条件){}else{}

         if(条件){}else if(条件){} ...else{}

        switch(表达式){ //switch表达式的值得类型byte short char int String
          case 值1:  break;
          case 值2:  break;
          case 值3:  break;
          default:  break;
       }  

       每一个case得值不能重复。
       default 找到不匹配的case时执行default的语句。
       break执行完对应的case后 跳出switch语句，如果没有使用break则找到匹配的case后                   会把后面所有的语句都执行。

        二，循环结构

        循环四要素： ①初始化变量，②循环条件，③循环体，④循环变量的自增

        while(条件){//条件是boolean值。
             
        }  
        
        do{}while(条件);
        
        
        for(初始化变量①；判断条件②；步进表达式④  ){     //初始值只会被执行一次

                        ​ 循环体③；

        
      }

三、类与对象

         类:具有相同属性和行为的一组对象的集合。 抽象的概念。
         对象: 万事万物皆为对象。 具体存在的实物。

        总结：类是对象的模板，对象是类的实例化。类只有通过对象才可以使用，而在开发之中应该先产生类，之后再产生对象。

四，方法/函数的定义和使用

        如何定义类：

        //权限修饰符     静态的   返回值类型  方法名
    public     [static]     void     show(int a,String b){
              //成员变量
              //成员方法
    }

         //如何根据类创建对象
        类名 对象名=new 类名();
        //对象如何调用类中的成员.
        对象名.成员变量;
        对象名.成员方法(实参)

五，数组

        数据类型[]  变量名=new 数据类型[长度];
        数据类型[]  变量名={值，值，值，值}；

        排序: 冒泡排序   选择排序【擂台排序】。

        1.冒泡排序

代码

void BubbleSort(int a[], int len)
{
	int i, j, temp;
	for (j = 0; j < len - 1; j++)
	{
		for (i = 0; i < len - 1 - j; i++)
		if (a[i] > a[i + 1])
		{
			temp = a[i];
			a[i] = a[i + 1];
			a[i + 1] = temp;
		}
	}
}

        2.选择排序【擂台排序】

假如给定初始数据：（118，101，105，127，112）

一次排序：101，118，105，127，112

二次排序：101，105，118，127，112

三次排序：101，105，112，127，118

四次排序：101，105，112，118，127

 1 /**
 2  * 选择排序
 3  * @param array 待排序数组
 4  * @return 已排序数组
 5  */
 6 public static int[] selectionSort(int[] array) {
 7     int len = array.length;
 8     // 如果数组长度为0或者1，都是不用排序直接返回
 9     if(len == 0 || len == 1) {
10         return array;
11     }
12     for(int i = 0; i < len - 1; i++) {
13         int minIdx = i;
14         for(int j = i + 1; j < len; j++) {
15             // 找到最小的数
16             if(array[minIdx] > array[j]) {
17                 // 保存最小数的索引
18                 minIdx = j;
19             }
20         }
21         // 如果一轮比较下来都没有变更最小值的索引则无需调换顺序
22         if(minIdx != i) {
23             int tmp = array[i];
24             array[i] = array[minIdx];
25             array[minIdx] = tmp;
26         }
27     }
28     return array;
29 }

六，三大特性

        封装: 把类中成员使用private进行封装，使外界无法之间调用。---安全。
                   一般: 封装属性。并且生成getter和setter方法。
             
        继承： 一个子类继承父类中的成员 extends ------
                    public class 子类名 extends 父类名{
            
            
            }

        overload重载 和 override重写？
               overload:在同一个类中，出现方法名相同，参数列表不同的方法。不考虑返回类型。这些方法就是就是反复重载。
               override:在父类和子类之间，子类中出现了和父类中方法名一样，参数列表一样。返回值类型一样。访问修饰符不能小于父类方法得访问修饰符。
               抛出得异常不能大于父类中。 子类中出现的这种方法就是就是重写。

        多态 : 一个对象具有多种形态。
                 父类声明 对象名=new 子类对象();//向上转型： 对象名.方法(); 调用的是子类重写的方法
                 子类声明 对象名=（子类）父类对象; //向下转型。

访问修饰符:
       public: 同一个工程下都可以访问。
       protected: 同包或者不同包下的子类访问。
       默认:  同包访问
       private: 同类访问。

七，抽象类（abstract）和接口（interface）

               抽象类:只能被继承，因为他不能实例化对象。 抽象类中有构造方法。抽象类中可以有非抽象方法。 抽象类中的属性可以是普通属性也可以是静态属性。

                抽象类：[权限修饰符]  abstract  class  类名{}

                抽象方法：[权限修饰符]  abstract  返回值  方法名();//没有大括号

               接口: 可以被多实现。 没有构造方法。 全是抽象方法【jdk8后出现了默认方法 和静态方法】。都是静态常亮。

                接口就是一个特殊的抽象类

八，异常处理

         try{

                }catch(

                异常类型 对象

                ){}
       throws 抛出异常。---->throws加在方法参数的后面 谁调用该方法谁处理这个异常。

九，集合

        集合:
        Collection（所有集合的父类）:

           List: 有序 可重复
              ArrayList: 底层数组：查询快，缺点:前提不是尾部元素,插入和删除慢。
              LinkedList: 底层链表.有点： 插入和删除快
              Vector:数组

           Set: 无序 不可重复。
              HashSet: 底层是按照hash表执行。 先按照hashcode表比对如果hash相同【hash冲突】，则按照equals方法比对。如果equals也相同则视为同一个元素。
              TreeSet: 底层树形结构 元素拍好序的。
              LinkedHashSet: 排序好序得  按照添加的顺序
              
        
        Map:
           HashMap:原理： map.put(key,value); map.get(key);  数组+链表【超过8】+红黑树。
           TreeMap:      

这篇关于JAVA基础基础知识总结的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！