java基础靠前必备知识讲解大全——你要的全都有！！！

一.java程序设计基础

1.标识符，关键字，注释

标识符：字母，下划线，美元符号开始的字符序列，不能包含运算符和特殊字符，且标识符对大小写敏感

关键字：java中含有特殊含义的字符序列，所有关键字都是小写。

注释：注释分三种。见下图，请读者仔细观察以下结构

//单行注释

/*
巧克力冰沙酱最可爱.这种事多行注释
*/

/**注释文本
*@awsl 猫咪
*
*/

2.常量和变量

1.常量：在前面加一个final关键字即可。

final int MAX=100;//如果常量由多个字母组成，则大写
final int MAX_COUNT=15;//多个单词组成，每个单词大写，用下划线连接

变量：值可以修改，是基本的储存单元。
注意：要初始化。（这点在力扣题目中抓的很严格）
变量分类：局部变量，类成员变量，方法参数。局部变量在代码块内声明，而类成员变量作用整个类。
注意：作用域中，变量名唯一。

3.基本数据类型

（这里只讲重点！语言中这些都是基础知识）
布尔类型：关键字boolean，返回的是false和true。

字符类型：有字符变量和字符常量。字符变量一般用char来定义，要加‘’（单引号），而字符常量一般为java中的转移字符。

浮点类型 ：float（单精度浮点数），double(双精度浮点数）
区别：一个浮点型默认为double，在浮点数后加F或者f表示float，否则报错

float f=3.4;//错误，后面没有f或F，下面两种才正确
float f=3.4f;
float f=3.4F;

4 . 字符的强制转化

字符转化由低级到高级是自动的。
下面由低到高给出数据类型的排序
byte，short，char，int，long，float，double

而强制类型转化，是由高到底的，在变量面前吧需要转化的目标类型放在括号里既可

5.运算符

6.程序控制语句

1.if
条件分支语句，可以直接if嵌套，也可以是if-else-if阶梯型语句

2.switch
多路分支语句，格式如下

switch(expression){
case value1:
//语句序列
break;
case value2:
//语句序列
break;
default;
//默认语句序列
}

其中，value必须是expression类型兼容的常量，重复的case值是允许的。运行时会与case中常量进行比较，如果没有与之匹配，则执行default语句，如果没有default语句则什么也不执行

3.while与do-while语句
while：

while(condition){
//循环体
}//先判断后执行

do-while

do{
//代码块
}while(condition);//注意这里有一个分号，丢了则运行错误
//先执行后判断

4.for语句
常见用法

for(initialization;condition;iteration){
//括号内用分号隔开。第一个分号前为初始值，也可以定义一个新的变量，第二个分号前为判断条件，第二个分号后为计算表达式。
//括号里是循环体。
}

for经常用于遍历，也可以嵌套。for循环中初始化和迭代部分可以为空，但里面必须有两个";",并且，如果for循环三个部分全部为空，则为无限循环。

for-each用法

for（int e:a)
 sum=sum+e;
 //for(int e:a)表示for each int e in a；表示对于数组a中的每一个元素e，其中，a为数组名

5.break
break作用是推出循环，可以用于任何java循环中，在一系列嵌套循环中，它仅仅终止最里面的循环。
6. continue
使当前循环结束，提前进入下一次循环。

7.return语句
用来明确的从一个方法返回，使程序控制权返回到调用它的方法，属于跳转语句。

二.数组

1.一维数组

1.定义数组

一维数组定义格式如下
数据类型 数组名[];
数据类型 []数组名;

int a[];
int []a;

2.生成数组

数组定义只是建立了一种数据的引用，还必须使用关键词new为其分配内存空间，否则无法被访问。
注意，定义时括号里的为数组总共的元素个数。

int a[]=new int[10];
int []a=new int[10];

3.初始化数组

正确初始化数组

int s[]=new int[3];
s[0]=1;
s[1]=2;
s[2]=3;//提醒初学者：注意数组第一个数的下标是0，以此类推

错误初始化数组
对数组整体复制

int s[3]={1,2,3};
//编译器会告诉你已经能够识别数组的元素个数
//正确操作如下
int s[]={1,2,3};

4.访问数组

直接利用索引

//访问下标为1的值
int a[]=new int[3];
a[0]=1;
a[1]=2;
a[2]=3;
//查找
System.out.println(a[1]);

2.二维数组

由于二维数组在初学时非重点，所以这里只是概括总结
定义：

int temp[][];
temp=new int[2][3];
//或者一气呵成
int temp[][]=new int[2][3];

其中，第一个括号中为行，第二个括号里为列。定义时括号里的为数组总共的行和列。

3.Arrays类

是java在包java.util中定义的一个类。。包含了以下几种用static修饰的静态方法,这里只讲常见
1.static boolean equals(type[]a,type[]b);
比较两个类型为type的数组是否相等
2.static void sort (type[] a);
对类型为type的数组排序，默认从小到大

4.动态数组

有了动态数组的基础我们可以实现队列，栈等简单的数据结构，有一定基础或者兴趣的同学可以了解，链接如下：
动态数组

提前了解对以后有所帮助，但这里不要求掌握。

三.类和对象设计——类

1.面向对象的基本特点

封装：将操作和操作所涉及的数据捆绑在一起，使其免受外界干扰和误用的机制。在java中，最基本的封装单元是类，一个类定义为具有相似特征对象的一种抽象。

继承
继承是指一个新的类继承原油类的基本特征，并可增加新的特性，原有的类成为父类或基类，新的类成为子类或派生类，子类中包含父类所有的数据和方法，也可以增加属性和方法。

多态性
类中统一名称的行为（或方法）可以有多种不同的功能，或者相同的接口有多重实现方法。

2.主类

定义：类的名字和文件名一致i，并且包含main函数的类
特征：一般用public修饰

3.定义类

1.如何定义：用关键词class进行表示。基本形式如下：

[类修饰符]class 类名 [extends 父类名][implements 接口名]

2.定义成员变量

[修饰符]类型 成员变量名列表

3.定义成员方法

[修饰符][返回值类型][方法名](参数列表）
{
方法体
}

4.方法重载

java允许使用同一个名字去定义多个方法。然而这多个方法不能完全一样（与重载无关），避免概念混淆。
而方法重载是使得类中两个相似的方法可以拥有完全相同的名字，也可以更灵活的给予所接受的参数调用不同方法。
可以看一下下面这个代码，两个名字相同的方法，一个是正儿八经的赋值，还有一个是初始化。参数不一样，作用不一样，这就是方法重载（构造方法）。
作用是方便对象的初始化。

5.代码示例

public class School{//主类
class Student{
    String Name;
    int Age;//两个成员变量
   
    public void Student(String Name,int Age){
        this.Name=Name;
        this.Age=Age;
        }//构造方法，作用是方便对对象初始化，且构造方法的名字和类名相同，也可以有很多个构造方法
     public void Student(){
         this.Name=null;
         this.Age=null;
         }
}
//下面可以是方法体了
}

四.类和对象设计——对象

1.什么是对象

前文说过，类，定义为具有相似特征对象的一种抽象，就好比我们所说的“物以类聚”，一个道理，类实际上是一个种类，而类里面有很多的成员变量。成员变量就是类里面的个体的一些共同特征。而这些个体，实际上就是我们的对象。（够通俗了叭，手动dog，好好理解啊亲）

2.实例化对象

类名 对象名=new 类名（[参数列表)];
Point p1=new Point();
Point p2=new Point();

3.对象的比较

一般情况下，==和!=用于两个对象的比较时，它不是比较两个对象的“值”是否相等，而是判断运算符两边是否是 同一个对象（地址空间是否相同），而比较两个对象，若使用两个=，则结果为false，可以用equals()方法，如p1.equals(p2)。

4.初始化对象

利用构造方法可以初始化对象。就是为所创建对象的成员变量赋初值。如上一节的代码，初始化对象。

5.使用对象

调用方法：运用点运算符。比如，现在有一个PassText的类，该类有一个成员a，初始化一个对象p，在初始化完成后调用对象p中的a，下面代码将依次进行该步骤

class PassText{
int a;//定义了成员变量

//要在类里面
public int PassText(int a){
this.a=a;
}
public int PassText(){
this.a=null;
}
}
//进行初始化
PassText p=new PassText(a);//在这一步中会调用构造方法
System.out.println(p.a);//输出

五.类及成员修饰符

1.public

可以同事修饰类，成员变量，成员方法。使用public，则该类或者该成员，方法，不光可以被其内部成员访问，还可以被其他类直接访问。

2.protected

主要用于修饰类成员，说明该类成员是被保护成员，处理被类自身访问外，还可以被该类的子类与该类的在同一个包中的其他类访问。

3.private

主要用于修饰类成员，表示该类成员只能被自身类访问，其他任何类，包括该类的子类都无权修改或引用。只有通过声明public的方法才可以对这些数据进行访问。这就是我们可以去掌控用户需要什么，和我们需要隐藏什么算法。

4.final

可以用于修饰类，成员变量，成员方法，被final修饰的元素不允许再修改。用final修饰的类不能拥有子类，用final声明的方法不能再被重写，final修饰的成员变量不能再被赋值或修改。

六.继承与多态——继承

1.继承理解

就像是你继承你爹的财产，同样你也可以自己挣钱，那么你拥有的实际上是你爹的和你的，但是你爹只是拥有你爹手里的东西。
java中的类的继承也是这样，子类可以继承父类的东西，并且子类也可以在父类的基础上有更多的方法。
同样，你大概只有一个亲爹，子类也只能有一个父类。

2.类的继承

关键词：extends
格式：首先，得有父类，其次，子类继承父类

public class Father(){
int a=0;
}
public class Son extends Father(){
int b=1;
}
则我们可以定义一个父类对象f，一个子类对象s
Father f=new Father();
Son s=new Son();
下面是调用
System.out.print(f.a);//正确，a是父类的对象，父类有成员a
System.out.print(f.b);//错误，父类中没有b
System.out.print(s.a);//正确，s是子类的对象，子类中虽然没有a但是继承父类，所以可以用
System.out.print(s.b);//正确，子类中有成员b

3.继承与重写

在类的继承中，子类中新增的变量和方法与父类中原有的数据和方法同名，则会重写（覆盖）从弗雷继承来的同名对象和方法，重写有两种：变量重写，方法重写。
变量重写是指父类和子类中变量名和数据类型相同，而方法重写，是与重载相似，但更加严格，不仅名字一样，参数列表也要相同。

为什么要单独介绍这一块，因为根据不同的需求我们需要访问不同的类，有可能是访问父类，也有可能访问子类。

介绍关键词1：super（你爹yyds）
访问父类成员：super.成员方法（参数）
访问父类构造方法：super()，这是用于访问父类的午餐构造方法。
访问父类成员变量：super.成员变量

介绍关键词2：this（当前对象的引用）
访问当前成员：this.成员变量
访问当前成员方法：this.成员方法(参数)
访问当前构造方法:this()

七.继承与多态——多态，抽象类和方法

1.多态理解

简单来说，多态就是一个名称可以对应多种不同的实现方法。

2.抽象类与抽象方法

1.定义抽象类，实现抽象方法

定义抽象类：关键词abstract。
意义：没有完全实现的类，主要用来描述概念性内容，方法，然后在后面的子类中具体实现这些概念，提高开发效率，统一用户接口，所以抽象类更多是作为其他类的父类

abstract class Abs{
abstract void show();
abstract void show(int i);
}//定义了抽象类
public class Real extends Abs{
//注意！这里是继承关系
int x;
void show(){
System.out.println("x="+x);
}
void show(int i){
x=i;
System.out.println("x="+x);

注意：抽象类中含抽象方法，需要在子类种重写

2.接口

定义：接口是抽象类的一个集合，在接口中有很多种方法，让人能够一目了然，接口中的方法需要在丐姐偶的子类中重写
关键词：

[修饰符]interface 接口名
{
//变量和方法声明
}

注意：1.抽象类中可以有抽象方法，或者不是抽象方法，但是接口中所有方法都是抽象方法。
2 需要重写

3.接口实现

在抽象类中我们用extends来继承，但是如果是个接口，则我们需要用关键词implements来实现呢一个接口
方式：

class 类名 implements 接口名

八.内部类

分别是成员内部类，局部内部类，静态内部类，匿名内部类，感兴趣可以了解，后续博客可能会更新，请持续关注。

九.泛型

1.什么是泛型

泛型——参数化类型。可以将类型定义成参数形式。就比如我们的整型Integer，实际上泛型E也是一个类型，只不过Integer是系统内定的，E更加广泛，它代表一种类型，与C语言结构体有相似之处。

2.定义泛型类和方法

class 类名<E(数据类型)>{
public 返回值类型 方法名（E(数据类型）变量);
}

相关泛型日后会写博客具体讲解。

总结

本博客有详有略的讲述了java的基础篇，在java学习中还有很多地方可以提高，将在以后的博客中更新。另外，我还写了几篇数据结构的博客，感兴趣的猿友可以关注，今后我们一起学习，一起进步，一起变大佬！
谢谢大家！