JAVA基础语法——基础学习

---

前言

提示：这里主要是我学习Java的基础内容，后续我会把学到的知识补充到里面：

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、java是什么？

示例：java是面向对象编程语言，是一种计算机网络方面的编程技术手段，广泛应用于计算机网络技术编程、软件编程、信息技术开发、软件开发等领域，是新一代信息技术发展的重要基础性技术之一，也是高校计算机科学与技术专业的核心课程之一。（随着Java体系的越来越完善，面临着Java越来越卷，建议谨慎入坑）

1.计算机语言发展历史

Java是面对对象的，他和C语言有着很大区别，C语言是面向过程的

1.1.Java发展历史

▪ 1991年，Sun公司的Green项目，Oak
▪ 1995年，推出Java测试版
▪ 1996年，JDK1.0 ▪ 1997年，JDK1.1
▪ 1998年，JDK1.2，大大改进了早期版本的缺陷，是一个革命性的版本，更名为Java2
▪ 1999 Java被分成J2SE、J2EE 和J2ME，JSP/Servlet技术诞生
▪ 2004年，J2SE 5.0 (1.5.0) Tiger老虎.为了表示这个版本的重要性，J2SE1.5更名为J2SE5.0。
▪ 2006年，J2SE 6.0 (1.6.0) Mustang野马.此时，Java的各种版本被更名，取消其中的数字"2"：J2EE更名为Java EE, J2SE更名为 Java SE，J2ME更名为Java ME
▪ 2009年4月20日甲骨文收购Sun公司，交易价格达74亿美元
▪ 2011年，JavaSE7.0
▪ 2014年 ，JavaSE8.0
▪ 2017年，JavaSE9.0
▪ 2018年3月，JavaSE10.0
▪ 2018年9月，JavaSE11.0
▪ 2019年3月，JavaSE12.0
目前大多数公司使用jdk的版本是1.8.0

1.2.Java语言为什么这么火？

外部环境

	– 互联网的爆发式发展 
	– 互联网上的电脑硬件不同，软件环境差异较大。需要一个跨平 台的语言。 

Java核心优势与特点（掌握）

• [核心优势] – 跨平台

   ▪ Java是跨平台的 
  

Java程序的跨平台主要是指字节码文件可以在任何具有Java虚拟机的计算机或者电子设 备上运行，Java虚拟机中的Java解释器负责将字节码文件解释成为特定的机器码进行运行
Java和C跨平台原理的比较
Java：一次编译，到处运行
C：多次编译，到处运行

• [特点] – 简单、安全、完全面向对象、健壮

  ▪ Java是简单的
  - 不再有#include 和#define 等预处理功能 （C语言每次都要去写这些）
  - 不再有struct,union及typedef – 不再有函数
  - 不再有指针、不再有多重继承
  - 不再有goto – 不再有操作符重载(Operatior Overloading)
  - 不再有全局变量 取消自动类型转换,要求强制转换
  - 不再有手动内存管理

  ▪ Java是安全的
  - Java取消了强大但又危险的指针。由于指针可进行移动运算，指针可随便指向一个内存区域，而不管这个区域是否可用，这样做是危险的，因为原来这个内
  存地址可能存储着重要数据或者是其他程序运行所占用的,并且使用指针也容 易数组越界。
  - Java提供了自动内存管理机制，由垃圾回收器在后台自动回收,
  - Java在字节码的传输过程中使用了公开密钥加密机制(PKC)。
  - 而在运行环境提供了四级安全性保障机制：▪字节码校验器 -类装载器 -运行时内存布局 -文件访问限制

  ▪ Java是完全面向对象的
  - Java和C++都是面向对象语言。也就是说，它们都能够实现面向对 象思想（封装，继承，多态）。
  - 由于C++为了照顾大量C语言使用者而兼容了C，使得自身仅仅成为 了带类的C语言，多少影响了其面向对象的彻底性！
  - Java则是完全的面向对象语言，它句法更清晰，规模更小，更易学。 它是在对多种程序设计语言进行了深入细致研究的基础上，据弃了其他语言的不足之处，从根本上解决了c++的固有缺陷。

  ▪ Java是健壮的
  - Java的强制类型机制、异常处理、垃圾的自动收集等是Java程 序健壮性的重要保证。
  - 对指针的丢弃是Java的明智选择。
  - Java的安全检查机制使得Java更具健壮性。

Java技术平台（了解）

• 根据不同的技术规范，Java划分为3中结构独立但又相互依赖的技术分支
  ·1. Java SE（标准版）活跃在桌面领域，主要包含Java API组件。这个版本是Java平台的核心。
  ·2. Java EE（企业版）活跃在企业级领域，主要包含Java API组件、Web组件、事务组件、分布式组件、EJB组件、消息组件；这些后续设计Spring大家族，根据这些技术开发企业级应用。并且Java EE也是构建SOA架构（单体框架）的首选平台。Java EE是Java SE的扩展。
  ·3. Java ME（精简版）活跃在嵌入式领域，称为精简版是因为JavaME仅保留了Java API中的部分组件，以及适应设备的一些特有组件。Java ME是Java SE的内伸
  

Java体系结构的组成（背诵）

Java技术的核心就是Java虚拟机——所有Java程序都在其上运行，需要Java虚拟机、Java API和Java,class文件的配合，Java程序才能够运行。
Java程序从编写到最终执行的过程：简述如下

（1）(程序中创建的一个个类)一个A.java程序源文件执行javac命令后编程成A.class二进制的字节码文件
（2）.class文件会被ClassLoader装载到内存中，同时装载java相关核心类库
（3）调用字节码解释器或即时编译器（java是解释器和编译器混合执行）
（4）执行引擎调用操作系统或硬件运行

一段java代码是如何执行的？（背诵）

众所周知，java代码是不能直接在jvm上执行的，执行的是class文件，将java代码编程class文件，需要
常用的编译方法是：javac xxx.java
但目前常见的java编辑工具，如eclipse和ideal都自带自动编译动能

1. JVM、JRE和JDK的关系

JRE又叫Java Runtime Environment（Java运行时环境）

包括Java虚拟机和Java程序所需的核心类库等。核心类库主要是java.lang包：包含了运行Java程序必不可少的系统类，如基本数据类型、线程、异常处理类等，系统缺省加载这个包。

JDK

这不用多说了吧，开发Java必须安装jdk,而且jdk版本更新换代快，增加了许多语法糖，目前大多数使用的还是进度款1.8.0版本，JDK其中就包括JRE,其中的开发工具：编译工具(javac.exe)，打包工具(jar.exe)等。

JVM的构成（Java虚拟机）

▪ JVM是一种规范。就是一个虚拟的用 于执行bytecodes字节码的计算机。用来执行我们编译后的二进制字节码文件。
▪ Java虚拟机是Java最核心技术，也是跨 平台的基础。
▪ 可以使用软件来实现 – IBM, SUN, BEA等。你也可以自己 写一个JVM
▪ Java虚拟机的主要任务是装载class文件，并执行其中的字节码，不同的Java虚拟机中，执行引擎可能有不同的实现，
因此Java语言可以实现跨平台。

2. Java运行机制

1）编写java源程序

java源文件:指存储java源码的文件。

先来看看如下代码：如下：

public class Main {
    public static void a(){
        b();
    }

    public static void b(){
        c();
    }

    public static void c(){
        System.out.println("Hello world!");
    }

    public static void main(String[] args) {
        a();
    }
}
上面是一段很简单的代码，主体上就是：

（1）一个Main类

（2）上面定义了一个main方法

（3）该main方法调用了静态方法a

（4）方法a调用方法b

（5）方法b调用方法c

（6）方法c打印了“Hello world！”

	（1）java源文件名就是该源文件中public类的名称
	（2）一个java源文件可以包含多个类，但只允许一个类为public

2）编译java源代码
当java源程序结束后，就需要编译器编译。
安装好jdk后，我们打开jdk目录，有两个.exe文件，即javac.exe(编译源代码，xxx.java文件) 和 java.exe(执行字节码，xxx.class文件).
如下图所示：
javac.exe编译器将我们的main.java编译成main.class字节码文件
java源代码有几个类，就会编译成一个对应的字节码文件(.class文件)
注意：如类A引用类C，但类C不定义在类A的源文件中，编译后，类C也被编译成对应的字节码文件C.class
然后我们将我们写好的的代码编译为class字节码文件在jvm（Java虚拟机执行）

3）JVM如何执行字节码文件

	（1）装载字节码文件

当 .java 源码被 javac.exe 编译器编译成 .class 字节码文件后，接下来的工作就交给JVM处理。
JVM虚拟机的主要任务是装载class文件并执行其中的字节码，而class文件是由虚拟机的类加载器(ClassLoader)完成的，在一个Java虚拟机中有可能存在多个类加载器。

(2）将字节码文件存储在JVM内存区

当JAVA虚拟机运行一个程序时，它需要内存来存储许多东西。
比如如字节码，程序创建的对象，传递给方法的参数，返回值，局部变量以及运算的中间结果等，这些相关信息被组织到“运行时数据区”。其中，java栈，本地方法栈，程序计数器为线程私有，其余为线程共享
方法区
方法区用来存储解析被加载的class文件的相关信息。
当虚拟装载一个class文件后，它会从这个class文件包含的二进制数据中解析类型信息，然后将该相关信息存储到方法区中。
堆
堆是用来存储相关引用类型的，如new对象。当程序运行时，虚拟机会把所有该程序在运行时创建的对象都放到堆中。
PC寄存器
PC寄存器主要用来存储线程。当新创建一个线程时，该线程都将得到一个自己的PC寄存器(程序计数器)以及一个java栈。Java虚拟机没有寄存器，其指令集使用Java栈来存储中间数据。
栈区
栈区主要用来存储值类型的，如基本数据类型。需要注意的是，String为引用类型，是存在堆中的。
Java栈是由许多栈帧组成的，一个栈帧包含一个Java方法调用的状态，当线程调用一个方法时，虚拟机压入一个新的栈帧到该线程的Java栈中，当该方法返回时，这个栈帧从Java栈中弹出。
所以假设
mian方法对应栈帧m
a方法对应栈帧a
b方法对应栈帧b
c方法对应栈帧c
根据方法的调用，入栈顺序为：m，a，b，c
所以，栈帧出栈（即方法执行）顺序为：c，b，a，m

(3）执行引擎与运行时数据区交互

运行时数据区为执行引擎提供了执行环境和相关数据，执行引擎通过与运行时数据区交互，从而获取执行时需要的相关信息，存储执行的中间结果等

(4）执行引擎与本地方法接口

当要执行本地方法时，执行引擎将调用本地方法接口来获取相关OS本地方法。

(5）JVM在具体操作系统上执行

JVM通过调用本地接口来获取本地方法，从而实现在具体的平台上执行。比如在Linux系统上执行，在Window系统上执行和在Unix系统上执行。

安装Java 安装JDK 安装Java开发工具 准备JDK API

第一个java程序

我们在Java开发工具IDEA上编写代码到硬盘中，保存为：Welcome.java

public class Welcome{ public static void main(String[] args){ 
		System.out.println("Hello java!");
	 }
 }

编译阶段（编译器创建class字节码文件 ）

• 进入java文件所在目录，打开cmd，执行命令：javac Welcome.java
• 编译时必须加上扩展名.java。
  执行阶段：
• 进入java文件所在目录，执行命令：java Welcome
• 运行的是类而非class文件，所以类名后不能加扩展名.class

注意

注释不会出现在字节码文件中。 即Java编译器编译时会 跳过注释语句。
编译– 源代码通过编译成class文件·
反编译 – class反编译为源代码
因为编译的时候不会对注释进行处理，所以反编译时不可能得到注释

2.Java数据类型和运算符

2.1.标识符

标识符Identifier

Java语言中，对于变量，常量，函数，语句块的名字，我们统统称之为Java标识符。
标识符是用来给类、对象、方法、变量、接口和自定义数据类型命名的。
作用

• 常量、变量、方法、类和包等的名称

命名规则

• 必须以字母、_下划线、美元符$开头。
• 其它部分可以是字母、下划线“_”、美元符“$”和数字的任意组合 – 大小写敏感，长度无限制。
• 不可以是Java的关键字。
• 最好是按照规范来进行命名 如下：

类和接口名	每个字的首字母大写，含有大小写。例如，MyClass，HelloWorld，Time等
方法名	首字符小写，其余的首字母大写，含大小写。尽量少用下划线。例如，myName，setTime等。这种命名方法叫做驼峰式命名
常量名	基本数据类型的常量名使用全部大写字母，字与字之间用下划线分隔。对象常量可大小混写。例如，SIZE_NAME
变量名	可大小写混写，首字符小写，字间分隔符用字的首字母大写。不用下划线，少用美元符号。给变量命名是尽量做到见名知义

注意

• Java不采用通常语言使用的ASCII字符集
• Java采用unicode这样的标准的国际字符集。
• 因此，这里的字母的含义：英文、汉 字等等。(不建议大家使用汉字来定义标识符！)
  

关键字

Java关键字是Java语言保留供内部使用的,如class用于定义类。 关键字也可以 称为保留字,它们的意思是一样的。
▪ 注意：不要刻意去背！后面会慢慢介绍每个关键字的用法

字符集简介

▪ ASCII – 英文字符集 1个字节
▪ ISO8859-1 – 西欧字符集 1个字节
▪ BIG5 – 台湾的大五码，表示繁体汉字 2个字节
▪ GB2312 – 大陆使用最早、最广的简体中文字符集 2个字节
▪ GBK – GB2312的扩展，可以表示繁体中文 2个字节
▪ GB18030 – 最新GBK的扩展，可以表示汉字、维吾尔文、藏文等中华民族字符 2个字节
▪ Unicode – 国际通用字符集 2个字节

2.2.常量和变量

常量变量定义 – 在程序中存在大量的数据来代表程序的状态，其中有些数据在程序的运行过程中值会发生改变，有些数据在 程序运行过程中值不能发生改变，这些数据在程序中分别被叫做变量和常量。
变量举例： – 你这个人就是变量，人生就是未知的随时随地都会变化，人生无常啊
常量举例 – 常量就是不变的量
在实际的程序中，可以根据数据在程序运行中是否发生改变，来选择应该是使用变量代表还是常 量代表
《常量就是写死的值不变，变量就是随时变化的》

2.2.1常量分类

字符串常量 用双引号括起来的内容(“ABC”)
整数常量 所有整数 (250)
小数常量 所有小数(2.50)
字符常量 用单引号括起来的内容(‘a’,’A’,’0’)

布尔常量 较为特有，只有true和false
空常量 null

2.2.2变量分类

Java语言支持的变量类型有：
成员变量：在类体中定义的变量。
局部变量：在类的方法中定义的变量

局部变量

局部变量声明在方法、构造方法或者语句块中；
局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；
访问修饰符不能用于局部变量；
局部变量只在声明它的方法、构造方法或者语句块中可见；
局部变量是在栈上分配的。
局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。

package com.tu.Demo01;

public class Demo01 {
       int c = 1; //成员变量在类中方法外面 作用域在Demo01里面生效
  public void study(){
      int a ; //局部变量在方法中 如果这里加了访问修饰符就会报错局部变量不能用于修饰符
      {
          int b ; //局部变量在代码块中
      }
       System.out.println(a); //局部变量没有默认值，直接使用的话会报错。
  }
}

不是还有类变量、静态变量、和实例变量吗？如下：
成员变量在类体中定义的变量，在这个类中都会生效，成员变量有分为静态变量和实例变量，其中静 态变量又称为类变量。

类变量（静态变量）

1、类变量也称为静态变量，在类中以 static 关键字声明，但必须在方法之外。

2、无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。

3、静态变量除了被声明为常量外很少使用，静态变量是指声明为 public/private，final 和 static 类型的变量。静态变量初始化后不可改变。

4、静态变量储存在静态存储区。经常被声明为常量，很少单独使用 static 声明变量。

5、静态变量在第一次被访问时创建，在程序结束时销毁。

6、与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为 public 类型。
静态变量的默认值和实例变量相似。数值型变量默认值是 0，布尔型默认值是 false，引用类型默认值是 null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。

7、静态变量可以通过：ClassName.VariableName的方式访问。

8、类变量被声明为 public static final 类型时，类变量名称一般建议使用大写字母。如果静态变量不是 public 和 final 类型，其命名方式与实例变量以及局部变量的命名方式一致。

import java.io.*;
 
public class Employee {
    //salary是静态的私有变量
    private static double salary;  （salary，默认1值0.00）
    // DEPARTMENT是一个常量
    public static final String DEPARTMENT = "开发人员";  （大写字母）
    public static void main(String[] args){
    salary = 10000;
        System.out.println(DEPARTMENT+"平均工资:"+salary);
    }
}

实例变量

1、类变量（静态变量）和实例变量都是声明在一个类中，但在方法、构造方法和语句块之外；

2、当一个对象被实例化之后，每个实例变量的值就跟着确定；

3、实例变量在对象创建的时候创建，在对象被销毁的时候销毁；

4、实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；

5、静态变量在第一次被访问时创建，在程序结束时销毁。

6、实例变量可以声明在使用前或者使用后；

7、访问修饰符可以修饰实例变量；

8、实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；

9、实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；

10、实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。（完全限定名就是他的包类例如：org.springframework.util.StringUtils.isEmpty(str)）

import java.io.*;
public class Employee{
   // 这个实例变量对子类可见
   public String name;
   // 私有变量，仅在该类可见
   private double salary;
   //在构造器中对name赋值
   public Employee (String empName){
      name = empName;
   }
   //设定salary的值
   public void setSalary(double empSal){
      salary = empSal;
   }  
   // 打印信息
   public void printEmp(){
      System.out.println("名字 : " + name );
      System.out.println("薪水 : " + salary);
   }
 
   public static void main(String[] args){
      Employee empOne = new Employee("RUNOOB");
      empOne.setSalary(1000.0);
      empOne.printEmp();
   }
}

类变量和实例变量最大的区别：
在同一个类中，一个对象对这个变量修改后，其他对象在使用这个变量的时候，实例变量的值不变还是初始化时候的值，类变量的值会改变，类变量就像是这个类里所有对象公共的部分。
原因：
而在创建实例对象的时候，内存中会为每一个实例对象的每一个非静态成员变量开辟一段内存空间，用来存储这个对象所有的非静态成员变量值。即使两个不同的实例对象是属于同一个class类，但是它们的同名非静态成员变量在内存中占用的空间是不同的。
而所有的实例对象都共用一个类变量，内存中只有一处空间是放这个类变量值的。因此，如果一个对象把类变量值改了，另外一个对象再取类变量值就是改过之后的了。

Java是一种强类型语言，每个变量都必须声明其类型。
▪Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。
▪变量在使用前必须对其声明, 只有在变量声明以后，才能为其分配相应长度的存储单元，声 明格式为：
▪type varName [=value] [{,varName[=value]}] ； 例如：int aaa = 210;
▪注意事项：
–每个变量都有类型，类型可以是基本类型，也可以是引用类型。
–变量名必须是合法的标识符

常量名	基本数据类型的常量名使用全部大写字母，字与字之间用下划线分隔。对象常量可大小混写。例如，SIZE_NAME
变量名	可大小写混写，首字符小写，字间分隔符用字的首字母大写。不用下划线，少用美元符号。给变量命名是尽量做到见名知义

2.3.Java基本数据类型

Java是一种强类型语言 1. 常量是有数据类型的 2.变量都必须声明其数据类型。

2.3.1整型数据类型

整型常量

• 十进制整数，如：99, -500, 0
• 八进制整数，要求以 0 开头，如：015
• 十六进制数，要求 0x 或 0X 开头，如：0x15
  整型变量
  整型常量默认为int型，声明long型常量可以后加‘ l ’或‘ L ‘(建议使用大写， 小写容易误认为数字1)，、如： long a = 55555555; //不出错，在Int表示的范围内(21亿内)。
  long b = 55555555555;//不加l出错，已经超过int表示的范围。
  

2.3.2浮点型数据类型

浮点类型常量

• 十进制数形式，例如: 3.14、 314.0 、0.314

• 科学记数法形式，如 314e2 、314E2、314E-2
  double f = 314e2; //31410^2–>31400.0
  double f2 = 314e-2; //31410^(-2)–>3.14
  浮点型变量

• float类型：
  单精度类型，尾数可以精确到7位有效数字，在很多情况下，float类型的精度很难满足需求。

• double类型：
  双精度类型 精度是float类型的两倍，绝大部分应用程序都采用double类型。
  ▪注意–浮点常量默认为double。要变为float，需在后面增加F/f.
  如： 3.14F –浮点数存在舍入误差，很多数字不能精确表示。如果需要进行不产生舍入误差的精确数字计算，需要使用BigDecimal类。

   	注意点：涉及到计算最好使用BigDecimal，如果使用float或者double它会导致精度丢失。
   	例如，数据为2.3，如果使用float计算，他会变为2.29999999进行计算，这个时候我们只能再次对返回的数据进行四舍五入处理。
  

  

2.3.3字符数据类型（2个字节）

单引号用来表示字符常量。例如‘A’是一个字符，它与“A”是不同的， “A”表示含有一个字符的字符串。
char 类型用来表示在Unicode编码表中的字符。
Unicode编码被设计用来处理各种语言的所有文字，它占2个字节， 可允许有65536个字符；
ASCII码占1个字节，可允许有128个字符 （最高位是0），是Unicode编码表中前128个字符。
Java 语言中还允许使用转义字符 ‘\’ 来将其后的字符转变为其它的 含义，char c2 = ‘\n’; //代表换行符 char类型在内存中存储的是该字符的Unicode编码值，所以char类 型可以当做int类型来处理

2.3.4布尔数据类型（一位，不是一个字节）

boolean类型有两个值，true和false ▪ boolean 类型用来判断逻辑条件，一般用于程序流程控制
实践：
请不要这样写：if ( is == true && done == false ) ，只有新手才那么写。 对于任何程序员 if ( whether && !done ) 都不难理解吧。所以去掉所有的 ==fasle 和 ==true。

2.4.运算符

Java 语言支持如下运算符：

• 算术运算符: +，-，*，/，%，++，–
• 赋值运算符 = – 扩展赋值运算符:+=，-=，*=，/=
• 关系运算符: >，<，>=，<=，==，!=
• 逻辑运算符: &&，||，! – 位运算符: &，|，^，~ ， >>，<<，>>> (了解！！！)
• 条件运算符 ？：

2.4.1算术运算符

注意：
1：/ 除 6/4=1 6/4.0=1.5
2: %取模(求余) 6%4=2
3：+ 6+‘a’=103 6+“a“=6ª
4：++
▪a=2;b=++a+9;
▪a=2;b=a+++9;
+：字符串相加，只要有一个 操作数是字符串，自动变为字 符串相连
如下：

2.4.2赋值运算符

基本赋值运算符 =
扩展赋值运算符
算术运算符和赋值运算符结合(先算数在赋值)

2.4.3关系运算符

关系运算符
用来进行比较运算
▪ 关系运算的结果是布尔值：true/false
▪ 注意区分
==和=
不等于是！=不是<>

2.4.4逻辑运算符

逻辑运算符与布尔操作数一起使用，组 成逻辑表达式
▪ 逻辑表达式的结果是布尔值
▪ &和&&的区别 –

• “&”:无论任何情况，“&”两边的表达式都会参 与计算。
• “&&”: 当“&&”的左边为false，则将不会计算其右边的表达式。即左false则false
  “|”和“||”的区别与“&”和“&&”的区别类似。
  

2.4.5位运算符（了解）

位运算符是对操作数以二进制比特位为单位进行操作和运算，操作数和结果都是整型数。
如果操作的对象是char、byte、short，位移动作发生前其值会自动晋升为int，运算结 果也为int。

2.4.6条件运算符

• 语法格式 – x ? y : z
  • 唯一的三目运算符
  • 执行过程
    其中 x 为 boolean 类型表达式，先计算 x 的值，若为true，则整个三目运 算的结果为表达式 y 的 值，否则整个运算结果为表达式 z 的值。
  • 经常用来代替简单的if-else判断
    

2.4.7运算符的优先级(了解即可，不用刻意去记)

赋值<三目<逻辑<关系 <算术<单目

2.5.基本数据类型的类型转换

2.5.1赋值运算时的转换-自动类型转换

• 自动类型转换（小的类型byte自动转换为int）

byte b=10; 
System.out.println("b="+b); 
int n = b; 
System.out.println("n="+n); 
//内存中发生了什么
00001010   <--byte10
00000000 00000000 00000000 00001010 00001010   <--int 10 

• 类型转换的方向
  低---->高
  byte —> short,char—>int —>long—>float —>double
  

2.5.2赋值运算时的转换-强制类型转换

• 强制类型转换（大的int强制转成小的byte类型）

int n=270; 
System.out.println("n="+n); 
byte b = (byte) n; 
System.out.println("b="+b);
//内存中发生了什么
00000000 00000000 00000001 0000001110  --> 270
						   0000001110  --> 14

强转时，当心丢失数据或失真
当将一种类型强制转换成另一种类型，而又超出了目标类型的表示范围，就会被 截断成为一个完全不同的值。

总结：
当长度宽度小的类型赋值到宽度大的类型会自动转换
但是当宽度大的类型赋值到宽度小的类型是需要强制转换，而且容易丢失数据或失真 ，数据的精确度也会丢失。
尤其将整型常量直接赋值给byte, short, char等类型变量，而不需要进行强制类型转换，只要不超出其表数范围
short b = 12; //合法
short b = 1234567; //非法

3.流程语句控制

流程控制语句是用来控制程序中各语句执行顺序的语句，可以把 语句组合成能完成一定功能的小逻辑模块。

3.1.顺序结构

/*
 *顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行代码。
 * 顺序结构：从上往下，依次执行
 */
public class Demo01 {
	public static void main(String[] args) {
		System.out.println("A");
		System.out.println("B");
		System.out.println("C");
		System.out.println("D");
		System.out.println("E");
	}
}

3.2.分支结构

/*
 *条件语句可根据不同的条件执行不同的语句。包括if条件语句与switch多分支语句
 *if分支结构
 *if(条件表达式){
 *执行的代码块；
 *}
 */
public class IfDemo {
	public static void main(String[] args) {
		System.out.println("开始");
		// 定义两个变量
		int a = 10;
		int b = 20;

		if (a == b) {
			System.out.println("a==b");
		}
	
		int c = 10;
		if (a == c) {
			System.out.println("a==c");
		}
	}
}

/*
 *if -else 分支结构
 *if(条件表达式){
 *执行的代码块;
 *}else{
 *执行的代码块；
 *}
 */
public class IfElseDemo {
	public static void main(String[] args) {
		System.out.println("开始");
		// 定义两个变量
		int a = 10;
		int b = 20;
		int c = 10;
		if (a == b) {
			System.out.println("a==b");
		}else(a == c){
			System.out.println("a==c");
		}
	}
}


/*
 *if -else if -...-else 分支结构
 *if(条件表达式){
 *执行的代码块;
 *}else if(条件表达式){
 *执行的代码块;
 *}…(此处省略N个else if)
 *else{
 *执行代码块;
 *}
 */
public class IfElseIfDemo {
	public static void main(String[] args) {
		System.out.println("开始");
			// 定义两个变量
		int a = 10;
		int b = 20;
		int c = 10;
		if (a == b) {
			System.out.println("a==b");
		}else if(a == c){
			System.out.println("a==c");
		}else {
			System.out.println("b==c");
		}
	}
}


/*
 *switch 分支结构
 *执行流程说明
 *首先计算出表达式的值
 *其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
 *最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
 */
public class switchDemo {
	public static void main(String[] args) {
		System.out.println("开始");
		int weekday = 1;
		switch(weekday) {
		case 1:
			System.out.println("星期一");
			break;
		case 2:
			System.out.println("星期二");
			break;
		case 3:
			System.out.println("星期三");
			break;
		case 4:
			System.out.println("星期四");
			break;
		case 5:
			System.out.println("星期五");
			break;
		case 6:
			System.out.println("星期六");
			break;
		case 7:
			System.out.println("星期日");
			break;
		default:
			System.out.println("你输入的数字有误");
			break;
		}
	}
}

3.3.循环结构

/*
 *循环结构就是在满足一定条件的情况下反复执行某一个操作。包括while循环语句、do···while循环语句和for循环            
 *语句。
 *for循环
 */
public class ForDemo {
	public static void main(String[] args) {
		//原始写法
		System.out.println("1");
		System.out.println("2");
		System.out.println("3");
		System.out.println("4");
		
		//用循环改进
		for(int x=1; x<=4; x++) {
			System.out.println(x);
		}
	}
}


/*
 *while循环
 */
public class WhileDemo {
	public static void main(String[] args) {
		//原始写法
		System.out.println("1");
		System.out.println("2");
		System.out.println("3");
		System.out.println("4");
		
			//while循环实现
		int x=1;
		while(x<=4) {
			System.out.println(x);
			x++;
		}
	}
}


/*
 *do…while循环语句
 */
public class DoWhileDemo {
	public static void main(String[] args) {
		//原始写法
		System.out.println("1");
		System.out.println("2");
		System.out.println("3");
		System.out.println("4");
		
			//do...while改写
		int x=1;
		do {
			System.out.println("x");
			x++;
		}while(x);
	}
}


break的使用场景：
在选择结构switch语句中
​在循环语句中break的作用：跳出单层循环

continue
continue的使用场景：在循环语句中continue的作用：结束一次循环，继续下一次的循环

return的使用场景：
在循环语句中
在方法中return的作用：
可以从一个方法返回，并把控制权交给调用它的语句。直接结束整个方法，从而结束循环。

4.数组

4.1.数组概述

• 数组概述
  • 数组是(相同类型数据的)有序集合
  • 相同类型的若干个数据,按照一定先后次序排列组合而成。
  • 其中,每一个数据称作一个数组元素
  • 每个数组元素可以通过一个下标来访问它们.
  • 数组下标从0开始，元素顺序从1开始
• 数组特点
  • 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
  • 其元素必须是相同类型,不允许出现混合类型。
  • 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
• 数组与变量的区别
  • 声明一个变量就是在内存空间划出一块合适的空间 变量是单个数据
  • 声明一个数组就是在内存空间划出一串连续的空间 数组是一组数据
    如下：
    

4.2.数组使用

• 数组使用
  • 声明数组 int[ ] a;
    • 告诉计算机数据类型是什么
    • 数据类型 数组名[ ] ;
  • 分配空间 a = new int[5];
    • 分配空间: 告诉计算机分配几个连续的空间
    • 数据类型[ ] 数组名 = new 数据类型[大小] ;(声明数组并分配空间)
  • 赋值 a [0] = 8;
    • 赋值：向分配的格子里放数据
  • 处理数据 a [0] = a[0] * 10;
  • 常见错误
    • 编译出错，没有写明数 组的大小
    • 编译出错，数组 越界 （你定义数据大小为3但是你查询数组下标为3的值导致数组越界异常）
    • 编译出错，创建数组并 赋值的方式必须在一条 语句中完成

			public static void main(String[ ] args){ 
			int[ ] score = new int[5]; 
			score = {60, 80, 90, 70, 85}; 
			int[ ] score2; 
			score2 = {60, 80, 90, 70, 85};
			 }

总结

提示：Java基础语法就到这里了，后续我还会更新，像方法，二维数组，一些简单的排序等…