温馨提示：这篇文章已超过469天没有更新，请注意相关的内容是否还可用！
摘要：，，本文提供Java入门级基础教学的详细整合内容，旨在帮助初学者快速掌握Java编程基础。文章详细介绍了Java语言的基本概念、语法、数据类型、运算符、流程控制、面向对象编程等核心知识点，内容详尽且具有极高的实用性。通过本文的学习，初学者可以迅速掌握Java编程的基本技能，为进一步深入学习Java打下坚实的基础。
目录
一：基础语法
1.“Hello word”
2.Java的运行机制
3. Java基本语法
1.注释、标识符、关键字
2.数据类型（四类八种）
4.类型转换
1.自动转换
2.强制转换
5.常量和变量
1.常量
2.变量
3.变量的作用域
6.运算符
1.算数运算符
2.赋值运算符
3.关系运算符
4.逻辑运算符
5.自增、自减运算符
二：Scanner与流程控制：
1.Scanner用法
2.流程控制
1.顺序结构
3.if选择结构
1.单if语句
2.标准语句
3.扩展语句
4.switch选择结构
1.break关键字
2.default关键字
3.continue关键字
5.循环结构
1.while循环
2.do while循环
3.for循环（重点）
4. 增强for
三：方法的定义和调用
四：数组
1.维数组
1.数组的定义
2.动态和静态数组
3.数组的打印输出
4. Java内存
4.数组的使用
2.二维数组
3.冒泡排序法（江湖中人尽皆知）
五：什么是面向对象
六：类与对象的关系
1.什么是类
2.什么是对象
3.创建与初始化对象
1.什么是类
2.什么是构造器
3.创建对象内存分析
七：封装、继承、多态
1.封装
2.继承
3.this和super关键字
4.方法重写
静态方法：
非静态方法：
5.多态
6.instanceof关键字
7.static关键字
8.抽象类
9.接口
10.内部类
1.成员内部类
2.静态内部类
3.匿名内部类
4.局部内部类
11.异常
1.抛出以及捕获异常
2.自定义异常
一：基础语法
1.“Hello word”
1.首先下新建一个文件夹存放代码，
2.新建一个Java文件来存放Java的相关代码。
注意点：文件的后缀名为Java（本文为Hellow.java）
public class Hello {
//class后面的名字应该和文件名保持一致，否则会报错
public static void main(String[] args){
System.out.print("Hello Word");
//System.out.print("XXX")打印输出语句
}
} 在cmd的根目录i下进行执行的时候采用javac Hellow.java 来执行文件会生成一个class文件，接着执行java Hellow来执行编译文件就会自动的打印输出Hello word！。
2.Java的运行机制
1.编译型：直接编译成系统可以理解的语言。这样的执行速度会更快。
2.解释型：把机器不懂的地方进行解释从而来进行执行。
Java编译器将准备好的源文件编译成了class文件，真正被执行的应该是class文件。此时将class文件放入到类加载器，放在Jvm中进行。字节码校验器来进行代码的校验，校验完成若没有了错误，此时的解释器便开始工作将我们的程序解释给操作系统从而进行解读。
3. Java基本语法
1.注释、标识符、关键字
注释（以代码为例）：
public class HelloWord {
public static void main (String[] args){
//单行注释：只能注释一行内容
//输出一个HelloWord
System.out.println("Hello Word!");
/*为多行注释：可以注释多行内容*/
/*System.out.println("Hello Word1!");
System.out.println("Hello Word2!");
*/
//JavDdoc文档注释
/**文档注释：可以加功能
* @Author 代码贩子、 --南京邮电大学
*/
}
} （标识符）：Java中所有的组成部分都需要名字。类名，变量名，以及方法名都称之为标识符。
注意点：所有的标识符都应该以（A——z）、$、或者是下划线开始的。
首字符之后可以是（A——z）、$、或者是下划线的组合。
关键字不可以作为名字。
可以是中文名字但是一般不采用，因为太Low，会被同行看不起。
标识符是大小写敏感的。
2.数据类型（四类八种）
Java为一款强类型的语言，所有变量的使用必须严格的符合固定，所有的变量只有被定义后才能进行使用。
4.类型转换
重点提示：（有人问为什么long占的字节比float的多还排在float后面？因为在发生转换的时候小数的优先级要大于整数。）不同类型的数据结构先转化为同一类型的，然后再进行计算。
强制转换分为两种，一种是从低到高的转换方法，一种是从高到低的转换方法。
1.自动转换
显式（规则：数据范围从低到高）：代码不需要进行处理并且直接可以完成转换。
/**
* @Author代码贩子、 --南京邮电大学
*/
public class HelloWord {
public static void main (String[] args){
//直接输出一个整数，默认是int型
System.out.println("30");
//直接输出一个小数，默认是double型
System.out.println("3.12");
//（1）左边是long类型，右边是int类型
//（2）=进行赋值，右边默认给左边 int——>long满足从低到高的转换规则
//（3）这一行代码发生了自动转换
long name1=100;
System.out.println(name1);
//(1)右边是float类型，左边是double类型
//（2）float->double，满足从低到高的转换规则
//（3）所以发生了自动转换
double name2=3.1415926F;
System.out.println(name2);
//(1)右边是long类型，左边是float类型
//（2）long->float,满足从低到高的转换规则
//（3）所以发生了自动转换
float name3=30L;
System.out.println(name3);
}
}
2.强制转换
代码需要进行处理不能够自动的完成转换。
格式：（范围小的类型）+范围小的变量名=（范围小的类型）+原本范围大的数据
注意：（1）在进行前置转换的时候可能会出现内存溢出、精度丢失等现象。
（2）byte/short/char这三种类型可以进行数学计算。
（3）byte/short/cha这三种类型在进行运算的时候首先会被默认为是int卡类型。
（4）布尔类型不可以进行任何的数据转换。
/**
* @Author代码贩子、 --南京邮电大学
*/
public class HelloWord {
public static void main (String[] args){
//（1）右边是long类型，左边是int类型
//（2）long->int 不是从高到低，所以需要进行强制转换
//（3）格式：（较小的数据类型）+较小的变量名=（较小的数据类型）+（原本范围较大的数据）
int nume1 = (int) 100L;
System.out.println(nume1);
//（1）右边是int类型，左边是int类型
//（2）int->byte
//（3）格式：（较小的数据类型）+较小的变量名=（较小的数据类型）+（原本范围较大的数据）
//写法一：
int a = 200;
byte b = (byte) a;
//写法二：
byte nume2 = (byte) 200;
//输出值为-56
//原因为200超过了byte的数据范围，发生了内存溢出的现象，所以在发生强制转换之后的输出值为负数。
System.out.println(b);
System.out.println(nume2);
float c = 3.14f;
int d = (int) c;
//此时的输出值为3
//因为在强制转换的时候float->int会发生精度丢失的问题，所以最后的输出值为3而不是3.14。
System.out.println(d);
//输出的值为97
char e ='a';
int f= (int)e;
System.out.println(f);
//输出的值为b
int g= f+1;
System.out.println((char) g);
//应该是20000000000，但是实际的结果输出的为一个负数
//那是因为计算的时候溢出了
int moeny = 10_0000_0000;
int years = 20;
int total = moeny*years;
System.out.println(total);
//虽然发生了自动转换还是输出的为负数
//因为默认是int并且在转换之前就已经出现了问题。
long total2 = total;
System.out.println(total2);
//此时输出的结果为正确的数值
//输出的结果为20000000000
//解决方法：先把一个数据转化为long类型
long total3 = moeny*(long)years;
System.out.println(total3);
}
} 5.常量和变量
1.常量
定义：在程序运行期间固定不变的量
格式：final 常量名 = 值；
final double PI = 3.1415926；
常量的分类：
（1）字符串常量：凡是用双引号引起来的量：如“ABC” "Hellow" "123"
（2）整数常量：无小数点的数字：如1 -100 0
（3）浮点型：直接写上的数字，有小数点：如2.5 -3.14 0.0
（4）字符常量：凡是用单引号引起来的单个字符：如‘A’ ‘b’ '1' '中'
（5）布尔常量：只有量中取值：如 true false
（6）空常量：null 代表没有任何的数组
/**
* @Author代码贩子、 --南京邮电大学
*/
public class HelloWord {
public static void main (String[] args){
//字符型常量
System.out.println("kj10");
System.out.println("");//两个双引号之间的内容为空，也有打印输出
System.out.println("ABC");
//整数常量（整数）
System.out.println(-400);
System.out.println(0);
//浮点型（小数）
System.out.println(3.14);
System.out.println(-0.25);
//字符常量
System.out.println('帅');
// System.out.println('AB');
// System.out.println('');//字符常量有且仅有一个字符，不能有两个，也不能为空
//布尔常量
System.out.println(true);
System.out.println(false);
//空常量
// System.out.println(null);//空常量不能直接打印输出
System.out.println();//或者什么都不写可以进行打印输出
}
}
2.变量
定义：可以随时发生变化的量，也是Java程序中最基本的储存单元，其要素包括变量名，变量类型和作用域。
注意点：（1）每个变量都有类型，类可以是基本类型也可以是引用类型。
（2）变量名必须是合法的标识符。
（3）变量声明的是一个完整的语句，所以每一个声明必须都要以分号结束。
（4）修饰符不存在前后的顺序，可以是 final static double PI = 3.1415926；也可以是 static final double PI = 3.1415926；
格式;数据类型 + 变量名 = 值；（可以用逗号隔开来来声明多个同类型的变量）。
/**
* @Author代码贩子、 --南京邮电大学
*/
public class HelloWord {
public static void main (String[] args){
//写法一:
//为了方便程序的可读性，所以不建议这么写
int a=1,b=2,c=3;
//写法二（推荐写法）：
int d = 1;
int e = 2;
int f = 1;
}
}
3.变量的作用域
（1）类变量：写在类里面的变量，加上satatic的关键字。
（2）实例变量：写在方法的外面，类的里面（从属于对象，或者理解为从属于这个类，要通过这个类来使用它，如果不规定初始值则利用的是初始值）并且不需要进行初始化。
（3）局部变量：写在方法里面的变量（包括写在主程序里面的方法），必须声明和初始化值。
/**
* @Author代码贩子、 --南京邮电大学
*/
public class HelloWord {
//类变量：加上关键字static
//类变量是从水属于这个类的，会随着这个类一起出来和消失。
static double saLary = 2500;
//实例变量：写在方法的外面，类得 里面。从属于对象或者是从属于这个类，要通过这个类才能使用它，可以不设置初始值
String name;
int age;
//主程序的方法或者是叫mian方法
public static void main (String[] args){
//局部变量是写在方法里面的，只对这个方法负责，跳出方法之外就不能被使用
//所有的局部变量必须声明和设置初始值
int i = 10;
System.out.println(i);
//使用面向对象的范畴
//左边的HelloWord为自定义类型，helloWord为引用类型
//变量类型+变量名字=值为new 变量HelloWord（）；将相当于拿到了自己，也就是把自己给自己才能拿到自己的实例变量
//如果实例化对象不给初始值，则会默认输出默认初始化的数值。
HelloWord helloWord= new HelloWord();
System.out.println(helloWord.name);
System.out.println(helloWord.age);
//类变量：加上关键字static
//如果去点static则不会被调用
System.out.println(saLary);
}
//新写的一个增加的方法
public void add(){
//这里不能说输出变量i是因为局部变量不在add的方法里面。
System.out.println(i);
HelloWord helloWord= new HelloWord();
//这里的add方法可以调用实例变量，是因为add方法在实例变量的作用域内
System.out.println(helloWord.name);
System.out.println(helloWord.age);
//这里的add方法也作用在类变量的作用域内，所以可以调用类变量
System.out.println(saLary);
}
}
6.运算符
1.算数运算符
算数运算符：+、-、*、/、%（取余）
/**
* @Author代码贩子、 --南京邮电大学
*/
public class HelloWord {
public static void main (String[] args){
long a = 3000000000000000000L;
int b = 20;
double c = 3.14;
int d = 10;
//因为有double类型的，所以输出为double类型
System.out.println(a+b+c+d);
//输出的为3000000000000000020，明显超出了int类型，因为有long类型，这里发生了自动转换，默认为龙类型
System.out.println(a+b);
}
} 2.赋值运算符
赋值运算符：=
赋值运算符：=、+=、-+、*+、/=、%=
（1）+= a +=3 相当于 a=a+3
（2）-= a -=3 相当于 a=a-3
（3）*= a *=3 相当于 a=a*3
（4）/= a /=3 相当于 a=a/3
（5）%= a %=3 相当于 a=a%3
注意事项：只有变量才能使用赋值运算符
/**
* @Author代码贩子、 --南京邮电大学
*/
public class fx{
public static void main(String[] args){
int a=10;
a+=5;
System.out.println(a);//15
}
} 3.关系运算符
关系运算符:>、=、
还没有评论，来说两句吧...