目录
一、Java是什么？
💖Java概念
💖Java运行机制
二、Java的语言基础
💖关键字
💖基本数据类型
💖运算符
三、Java逻辑控制
💖分支结构
💖循环结构
四、Java的方法
💖方法的定义
💖方法的重载
💖方法的递归
五.Java数组
💖一维数组
💖二维数组
六.类与对象
💖 基础概念
💖构造方法
💖封装
七.代码块
💖普通代码块
💖构造块
💖静态代码块
🎁博主介绍：博客名为tq02，已学C语言、JavaSE，目前学了MySQL和JavaWed
🎥学习专栏： C语言 JavaSE MySQL基础
🎄博主链接：tq02的博客_CSDN博客-C语言,Java,MySQL领域博主
一、Java是什么？
💖Java概念
Java是一门优秀的程序设计语言，是C语言基础之上更深一步的面向对象编程语言，拥有很多特性：简单性、面向对象性、分布性、稳健性、安全性、可移植性、多线程性等等，而Java不仅是一种编程语言，还是一种程序发布平台，可以分为：JavaEE、JavaSE和JavaME
Java 是拥有一套完整性系统学习的技术，而Java基础是重中之重，俗话说的好，只有基础打牢，万米高楼平地起。
public class 类名{
public static void main(String[] args) {
//程序代码
}
}Java程序的执行入口是main()方法，一般存在于public class类中，并且main()函数必须存在于class当中，而一个Java文件只能有一个public class，public class默认为主类，并且Java文件名字必须和主类相同。
💖Java运行机制
xxx.java的源文件先通过javac编译程序把源文件进行编译，编译后生成的.class文件是由字节码组成的平台无关、面向JVM的文件。最后启动java虚拟机（JVM）来运行.class文件，此时JVM会将字节码转换成平台能够理解的形式来运行。
结论：Java程序运行需要经过编译、运行两个阶段。
编译：Javac命令 运行：Java命令
二、Java的语言基础
每一种编程语言都拥有关键字、数据类型和运算符，关键字为Java语言本身提供的一种特殊的标识符，数据类型是规定变量的类型。数据类型分为基本数据类型、引用数据类型。
💖关键字
关键字有50个，以上是主要的关键字
💖基本数据类型
| 数据类型 | 类型名 | 类型大小及其描述 |
| int | 整形 | 4个字节 |
| long | 长整形 | 8个字节 |
| short | 短整型 | 2个字节 |
| double | 双精度浮点型 | 8个字节，但内存布局不同 |
| float | 单精度浮点型 | 4个字节，取值：数+F 内存布局不同 |
| char | 字符类型 | 2个字节，使用：单引号 + 单个字母 |
| byte | 字节类型 | 1个字节 |
| boolean | 布尔类型 | 由JVM实现而不同，占一个字节或1比特位 |
| String | 字符串类型 | 由字符组成，大小不确定。 |
在运算符当中，特别关注float和double的内存存储方式，学习链接：http://t.csdn.cn/tTo64
💖运算符
任何语言都缺少不了计算、比较、判断等操作，而进行这些操作基于运算符而实现。
运算符也有大小分，也就是优先级的顺序。
三、Java逻辑控制
逻辑控制语句分为顺序结构、分支结构和循环结构。
- 顺序结构比较简单，从上到下运行。
- 分支结构：从上到下运行，但是中途有分路，需要选择路径向下运行
- 循环结构：代码运行在一定的区域里循环运行，直到false跳出循环
💖分支结构
分支结构有2种语法结构：if语法 和 switch语法
if语法
基本语法1：if(布尔表达式){
//条件为true时，执行
}
基本语法2：if(布尔表达式){
//条件为true时，执行
}else{
//条件为false时，执行
}
基本语法3：if(布尔表达式){
//条件满足时执行代码
}else if(布尔表达式){
//条件满足时执行代码
}else{
//条件都不满足时执行代码
}
switch语法
基本语法：switch(整数|枚举|字符|字符串){
case 内容1 : {
内容满足时执行语句;
[break;]
}
case 内容2 : {
内容满足时执行语句;
[break;]
}
........ ........... .......... .............. ............ ......
default:{
内容都不满足时执行语句;
[break;]
}
}注：如果没有break，当符合其中一个内容时，还会再次执行下面的语句
💖循环结构
循环语句有2种语法：while、for、do while。而配合循环语句使用的有break、contain
break：跳出循环。 contain:停止本次循环，重新循环
while语句
基础语法：while(循环条件){
循环语句;
}当满足循环条件，则循环，不满足则不循环。可在循环语句当中使用 if语句，指定某个条件满足时使用break或者contain
for语句
基础语法1：for(表达式1;表达式2;表达式3){
循环体;
}
- 表达式1: 用于初始化循环变量
- 表达式2: 循环条件
- 表达式3: 设置循环变量的更改
当满足循环条件，则循环，不满足则不循环。可在循环语句当中使用 if语句，指定某个条件满足时使用break或者contain
基础语法2：for(数据类型 变量名：数组）
{ 循环体 ； }
变量名会遍历数组，并且每次循环，变量名会存储对应的数组值
do while语句
基础语法：do{
循环语句;
}while(循环条件);可先执行循环语句，再判断循环条件
四、Java的方法
Java的方法类似于C语言的函数，而使用方法可以使代码被重复利用，使代码更好理解。
💖方法的定义
基本语法： public static 方法返回值 方法名称（[参数类型 形参 ...]){
方法体代码;
[return 返回值];
}调用语法：数据类型 变量名 = 方法名称.( 实参);
注：
- 执行是main()方法，而main()方法是静态方法，只能调用静态方法，所以使用static，将该方法设为静态方法。
- 如果不使用static，那么只能通过对象调用
- 调用时不需要返回数据，则方法返回类型是void，无返回值。
- 对于基础类型来说, 形参相当于实参的拷贝. 即 传值调用
- 对于引用类型来说, 形参相当于实参的拷贝. 即 传址调用
💖方法的重载
方法的重载：相同的函数名，不同的形参列表和返回值类型
代码示例：
class Test {
public static void main(String[] args) {
int ret1 = add(2, 3);
double ret2 = add(2.5, 3.5);
double ret3 = add(2.5, 3.5,4.5);
public static int add(int x, int y) {
return x + y;
}
public static double add(double x, double y) {
return x + y;
}
public static double add(double x, double y, double z) {
return x + y + z;
}
}💖方法的递归
一个方法在执行过程中调用自身, 就称为 "递归"
//求总和
public static int sum(int num) {
if (num == 1) {
return 1;
}
return num + sum(num - 1);
}五.Java数组
数组就相当于一个容器，存放相同类型数据的容器，数组的学习主要是一维数组和二维数组。
💖一维数组
创建语法：
- 动态初始化
数据类型[ ] 数组名称 = new 数据类型 [ ] { 初始化数据 };- 静态初始化
数据类型[ ] 数组名称 = { 初始化数据 };
数组使用：
- 使用 数组名.length 能够获取到数组的长度
- 使用 [ ] 按下标取数组元素. 需要注意, 下标从 0 开始计数
- 使用 [ ] 操作既能读取数据, 也能修改数据.
- 不可以超出有效范围[0, length - 1]，不然会出现异常
- 只能存储相同类型的数据
- 在使用方法时，若传递的是数组，则进行的是传址调用
数组转换字符串
语法格式：String str1=Arrays.toSting( 数组名）;
数组拷贝
语法格式1：
数据类型[ ] newArr = Arrays.copyOf(数组名, 拷贝长度);
语法格式2：
数据类型[ ] newArr = Arrays.copyOfRange(数组名, 下标值front，下标值after);
//拷贝范围 下标值front-after
💖二维数组
概念：存放多个一维数组的容器
语法格式：数据类型 [ ][ ] 数组名称 = new 数据类型 [行数][列数] { 初始化数据 };
行：代表几个一维数组 列：代表一维数组的范围大小
而至于三维数组、四维数组也是相同的道理，但出现的频率少得可怜。
六.类与对象
💖 基础概念
类与对象之间的关系：类是设计图、而对象是根据设计图具体化出来的实例
基本语法：
//创建类 class <class_name>{ field;//成员属性 method;//成员方法 } // 实例化对象 <class_name> <对象名> = new <class_name>();class为定义类的关键字，ClassName为类的名字，{}中为类的主体。
类中的元素称为：成员属性。类中的函数称为：成员方法。
注：在类中的方法不需要static，此时此刻，实例化出来的对象，是可以直接调用该方法的
💖构造方法
构造方法是一种特殊方法, 使用关键字new实例化新对象时会被自动调用, 用于完成初始化操作
语法规则：
- 方法名称必须与类名称相同
- 构造方法没有返回值类型声明
- 每一个类中一定至少存在一个构造方法（没有明确定义，则系统自动生成一个无参构造）
注：this关键字使用，以此修改当前的成员属性
代码实例：
class Person {
private String name;//实例成员变量
private int age;
//默认构造函数 构造对象
public Person() {
this.name = "caocao";
this.age = 10;
}
//带有3个参数的构造函数
public Person(String name,int age,String sex) {
this.name = name;
this.age = age;
}
public class Main{
public static void main(String[] args) {
Person p1 = new Person();//调用不带参数的构造函数 如果程序没有提供会调用不带参数的构造函数
Person p2 = new Person("zhangfei",80,);//调用带有2个参数的构造函数
}
}💖封装
实例化出来的对象权利很大，可以改变成员属性的值，因此为了防止这种情况的出现，我们会使用private封装，从而，类的调用者无法使用。
class Person {
private String name = "张三";
private int age = 18;
public void show() {
System.out.println("我叫" + name + ", 今年" + age + "岁");
}
}
class Test {
public static void main(String[] args) {
Person person = new Person();
person.show();
}
}注：private 不光能修饰字段, 也能修饰方法，当没有使用priavte修饰时，默认为使用public
问：那么如果想要修改封装好的成员属性呢？
答：使用getter和setter方法，以及this关键字
使用this.属性名= " 新值 "；
代码示例：
class Person {
private String name;//实例成员变量
private int age;
public void setName(String name){
//name = name;//不能这样写
this.name = name;//this引用，表示调用该方法的对象
}
public String getName(){
return name;
}
}
public static void main(String[] args) {
Person person = new Person();
person.setName("caocao");
String name = person.getName();
System.out.println(name);
}注：
- getName 即为 getter 方法, 表示获取这个成员的值.
- setName 即为 setter 方法, 表示设置这个成员的值.
七.代码块
概念：使用 { } 定义的一段代码
而根据代码块定义的位置以及关键字，我们可以分为以下三种：
- 普通代码块
- 构造块
- 静态块
💖普通代码块
直接定义在方法中。在代码块中的变量，作用域只存在代码块中。
代码示例：
public class Main{
public static void main(String[] args) {
{ //直接使用{}定义，普通方法块
int x = 10 ;
System.out.println("x1 = " +x);
}
int x = 100 ;
System.out.println("x2 = " +x);
}
}
// 执行结果
x1 = 10
x2 = 100💖构造块
定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量
代码示例：
class Person{
private String name;//实例成员变量
private int age;
public Person() {
System.out.println("I am Person init()!");
}
//实例代码块
{
this.name = "tq02";
this.age = 22;
System.out.println("I am instance init()!");
}
public void show(){
System.out.println("name: "+name+" age: "+age);
}
}
public class Main {
public static void main(String[] args) {
Person p1 = new Person();
p1.show();
}
}
// 运行结果
I am instance init()!
I am Person init()!
name: bit age: 12 sex: man💖静态代码块
使用static定义的代码块。一般用于初始化静态成员属性。并且只能访问静态数据成员
代码实例：
class Person{
private static String name;//实例成员变量
private int age;
public Person() {
System.out.println("I am Person init()!");
}
//实例代码块
static {
name = "tq02";
System.out.println("I am instance init()!");
}
public void show(){
System.out.println("name: "+name+" age: "+age);
}
}
public class Main {
public static void main(String[] args) {
Person p1 = new Person();
p1.show();
}
}注：
- 静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的。
- 静态代码块执行完毕后, 实例代码块（构造块）执行，再然后是构造函数执行
文章幅度太长，决定分为2部分，以上部分较为简单，容易理解。
---------------懒惰的tq02
