从零开始看懂Java代码系列教程（Java基础篇）

发表于 | 分类于 | | 阅读次数

我每天都在面向“对象”编程。 ———来自本文作者的冷笑话。

阅读指南

这篇文章为Java最为基础的语言基础。也就是说，你完全可以泛读一遍，让心里有个印象，仅仅接受自己可以接受的知识点就好。我希望做到的是在你心里建立一个词典，知道有这么回事儿就好。然后在下次遇到的时候回到手头的文档，或者工具书（当然我会给你一本的），来查看就好。那个时候在力尽可能的弄清楚。请记住这个学习方法。或许这个方法在考试上无效，但是在学习编程和技术上可以大显神威的。

Java语法基础

基础概念

在Java中处理少数基础类型，其他的都是类和对象。

  • 类：英文就是Class。表示对具有相同一类属性的对象的一种抽象。（注意这里也说是一种抽象了，很有可能两个人的“抽”发很不同但是都可以去解决实际问题，老司机可以写出超级优秀的抽象）往往我们说，类具有熟悉和方法。
  • 对象：一个拥有具体属性和方法的“类”的实例。两个实例可以拥相同的属性和方法，但是却是两实例。
  • 实例：我们常常说某个对象，是某个类的实例。
  • 属性、方法： 描述一个类的特征，或者说对象拥有的特性。

一个列子全解决:
我们从小动物讲起。我们知道动物就是一个类，应为每个动物都有一些抽象出来的相同的属性和能力（这里可以理解为方法）。就属性来说比如毛发的颜色，身高体重之类的。然后动物又有一些统一的方法，比如走、跑、吃、喝。就相当于类下面的方法。但是我们说动物是个类是抽象的。那么我可以说一只兔子就是动物的一个实例。我就也就可以叫这只兔子是对象了。那么它的属性就确定下来，比如毛发是白色，身高一米二之类的。方法也确定下来，毕竟兔子的吃法和老虎的吃法是不一样的。

聪明的你一定发现了，有的时候我们可以认为兔子也是一个类，级别要比动物低一些，然后兔子有很多种类，很好吃的家养兔和不太容易吃到的野生兔子。当然还有很多其他的分类方法。那么Java可以表示这些关系吗？当然是可以的。这就要涉及到继承和多态了。不要急我会在OOP（面向对象编程）中非常详细的介绍的。

Java的命名规范

  1. 大小写敏感。
  2. 类名 首字母大小。然后如果由多个单词组成单词的首字母大小。比如HappyGirlClass。
  3. 方法名 方法名首字母要小写，后面的的单词首字母大写。比如findByPhoneNum。
  4. 源文件名 源文件名和类名保持一致。完全的一致，然后以.java结尾就好。

Java 关键字

Java的关键字，是不能用做变量名的字符串。也不是很多。下面有一张速查表方便你阅读。

关键字 描述
abstract 抽象方法，抽象类的修饰符
assert 断言条件是否满足
boolean 布尔数据类型
break 跳出循环或者label代码段
byte 8-bit 有符号数据类型
case switch 语句的一个条件
catch 和try搭配扑捉异常信息
char 16-bit Unicode字符数据类型
class 定义类
const 未使用
continue 不执行循环体剩余部分
default switch语句中的默认分支
do 循环语句，循环体至少会执行一次
double 64-bit双精度浮点数
else if 条件不成立时执行的分支
enum 枚举类型
extends 表示一个类是另一个类的子类
final 表示一个值在初始化之后就不能再改变了表示方法不能被重写，或者一个类不能有子类
finally 为了完成执行的代码而设计的，主要是为了程序的健壮性和完整性，无论有没有异常发生都执行代码。
float 32-bit单精度浮点数
for for循环语句
goto 未使用
if 条件语句
implements 表示一个类实现了接口
import 导入类
instanceof 测试一个对象是否是某个类的实例
int 32位整型数
interface 接口，一种抽象的类型，仅有方法和常量的定义
long 64位整型数
native 表示方法用非java代码实现
new 分配新的类实例
package 一系列相关类组成一个包
private 表示私有字段，或者方法等，只能从类内部访问
protected 表示字段只能通过类或者其子类访问子类或者在同一个包内的其他类
public 表示共有属性或者方法
return 方法返回值
short 16位数字
static 表示在类级别定义，所有实例共享的
strictfp 浮点数比较使用严格的规则
super 表示基类
switch 选择语句
synchronized 表示同一时间只能由一个线程访问的代码块
this 表示调用当前实例或者调用另一个构造函数
throw 抛出异常
throws 定义方法可能抛出的异常
transient 修饰不要序列化的字段
try 表示代码块要做异常处理或者和finally配合表示是否抛出异常都执行finally中的代码
void 标记方法不返回任何值
volatile 标记字段可能会被多个线程同时访问，而不做同步
while while循环

基本数据类型

我说过在Java中除了基础数据类型以外都是对象。那么我们先来看一下基础的数据类型。

字节型（byte）

字节型是一种 8 位有正负的二进制整数
最小值是 -128(-2^7)
最大值是 127(2^7-1)
默认值为 0
字节型数据类型主要是为了在大型数组内节省空间，主要是替代整数由于字节型比整数小 4 倍。
例如：byte a = 100 , byte b = -50

短整数（short）

短整数是一种 16 位有正负的二进制整数
最小值是 -32768(-2^15)
最大值是 32767(2^15-1)
短整数类型的数据也可以像字节型一样用于节省空间。短整数比整数小两倍
默认值为 0
例如：short s = 10000, short r = -20000

整数型（int）

整数型是一种 32 位有正负的二进制整数
最小值是 - 2,147,483,648(-2^31)
最大值是 2,147,483,647(2^31 -1)
整数型一般默认被应用于整数值除非担心内存不够用。
默认值为 0
例如：int a = 100000, int b = -200000

长整型（long）

长整型是一种 64 位有正负的二进制整数
最小值是 -9,223,372,036,854,775,808(-2^63)
最大值是 9,223,372,036,854,775,807 (2^63 -1)
这种数据类型一般是在需要比整数型范围更大时应用。
默认值为 0L
例如：long a = 100000L, int b = -200000L

浮点型（float）

浮点型数据是一种单精度的 32 位 IEEE 754 标准下的浮点数据。
浮点型数据主要是为了在大型浮点数字数组中节约内存。
默认值是 0.0f。
浮点型数据不能用于如货币这样的精确数据。
例如：float f1 = 234.5f

双精度型（double）

双精度型数据是一种双精度的 64 位 IEEE 754 标准下的浮点数据。
这种数据类型主要是默认被用于表示小数的值，一般是默认的选择。
双精度型数据不能用于如货币这样的精确数据。
默认值是 0.0d
例如：double d1 = 123.4

布尔型（boolean）

布尔型数据代表一个信息比特。
它只有两个可能的值：真（true）和假（false）
这种数据类型用于真假条件下的简单标记。
默认值是假（false）
例如：boolean one = true

字符型（char）

字符型数据是简单的 16 位 Unicode 标准下的字符。
最小值是： ‘\u0000’ (或 0)。
最大值是： ‘\uffff’ (或 65,535 )。
字符型数据可以用来储存任意字母。
例如： char letter A（字符型的字母A） =’A’

引用数据类型

引用数据类型是由类的编辑器定义的。他们是用于访问对象的。这些变量被定义为不可更改的特定类型。例如：Employee， Puppy 等等。
类对象和数组变量就是这种引用数据类型。
任何引用数据类型的默认值都为空。
一个引用数据类型可以被用于任何声明类型和兼容类型的对象。
例如：Animal animal = new Animal(“giraffe”)；

也就是在你定义一个变量的时候必须知道他的类型，这也是为什么Java也是强类型的原因

变量

去一个例子，直接来看看这些变量的使用和这些变量的修饰符。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/**
* 我们建立一个兔子类
*/
public class Rabbit{
    //兔子眼睛颜色是一个可以被外部访问的public变量
    public String eyeColor;
    //兔子有一个私有的名字只能被内部访问
    private String myName;
    
    // 这里兔子都有一个共通的属性就是可以吃不 我这里设置成可以:)
    // 这里的值还是可以改变的只不过改变了一个 其他所有的实例都改变了
    // 比如那天通过了一条法律兔子不能吃了 这个值设置成false了
    private static Boolean canBeEat = true;
    // 那么我们现在为了品尝到人间的美味就要设置成fianl 这样就不能改变了
    // 这个值就成了一个真正意义上的常量。你可以烹饪兔子吗？当然可以
    // 这个意味着这个值是变化不了的
    public static final String CANBECOOKED = "Yes,You can.";
}

流程控制

这里就是每个语言都要有的流程控制了。很简单看看就好。

循环控制

while 循环

while循环是一个控制结构，可以重复的特定任务次数。

  • 语法
    1
    2
    3
    4
    while(Boolean_expression)
    {
       //Statements
    }

在执行时，如果布尔表达式的结果为真，则循环中的动作将被执行。只要该表达式的结果为真，执行将继续下去。
在这里，while循环的关键点是循环可能不会永远运行。当表达式进行测试，结果为假，循环体将被跳过，在while循环之后的第一个语句将被执行。

do…while 循环

do … while循环类似于while循环，不同的是一个do … while循环是保证至少执行一次。

  • 语法
    1
    2
    3
    4
    do
    {
       //Statements
    } while (Boolean_expression);

请注意，布尔表达式出现在循环的结尾，所以在循环中的语句执行前一次布尔测试。
如果布尔表达式为真，控制流跳回，并且在循环中的语句再次执行。这个过程反复进行，直到布尔表达式为假。

for 循环

for循环是一个循环控制结构，可以有效地编写需要执行的特定次数的循环。
知道一个任务要重复多少次的时候，for循环是有好处的。

  • 语法
    1
    2
    3
    4
    for(initialization; Boolean_expression; update)
    {
       //Statements
    }

下面是一个for循环的控制流程：

  • 初始化步骤首先被执行，并且仅一次。这个步骤可声明和初始化任何循环控制变量。不需要把一个声明放在这里，只需要一个分号出现。
  • 接下来，布尔表达式求值。如果是 true，则执行循环体。如果是false，则循环体不执行, 并且流程控制的跳转到经过for循环的下一个语句。
  • 之后循环体在for循环执行时，控制流程跳转备份到更新语句。该语句允许更新任何循环控制变量。这个语句可以留空，只要一个分号出现在布尔表达式之后。
  • 布尔表达式现在再次评估计算。如果是true，循环执行，并重复这个过程（循环体，然后更新的步骤，然后布尔表达式）。之后，布尔表达式为 false，则循环终止。
  • 示例
1
2
3
4
5
6
7
8
9
10
public class Test {
   public static void main(String args[]) {
      for(int x = 10; x < 20; x = x+1) {
         System.out.print("value of x : " + x );
         System.out.print("\n");
      }
   }
}

for 循环在 Java 中新特性

  • 语法
    1
    2
    3
    4
    for(declaration : expression)
    {
       //Statements
    }
  • 声明: 新声明块变量，这是一种与你所正在访问数组中的元素兼容的变量。该变量在for块内可被利用并且它的值作为当前的数组元素将是相同的。
  • 表达: 这个计算结果完成需要循环数组。表达式可以是一个数组变量或返回一个数组的方法调用。
  • 示例
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    public class Test {
       public static void main(String args[]){
          int [] numbers = {10, 20, 30, 40, 50};
          for(int x : numbers ){
             System.out.print( x );
             System.out.print(",");
          }
          System.out.print("\n");
          String [] names ={"James", "Larry", "Tom", "Lacy"};
          for( String name : names ) {
             System.out.print( name );
             System.out.print(",");
          }
       }
    }

break 关键字

关键字break是用来停止整个循环的。 break关键字必须使用于任何循环中或一个switch语句中。
关键字break将停止最内层循环的执行，并开始执行在块之后的下一行代码。

  • 语法

    1
    break;

  • 示例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    public class Test {
       public static void main(String args[]) {
          int [] numbers = {10, 20, 30, 40, 50};
          for(int x : numbers ) {
             if( x == 30 ) {
              break;
             }
             System.out.print( x );
             System.out.print("\n");
          }
       }
    }

continue 关键字

continue关键字可以在任一环的控制结构使用。它使循环立即跳转到循环的下一次迭代.

  • 在for循环中，continue关键字会导致控制流立即跳转到更新语句。
  • 在一个while循环或do/while循环，控制流立即跳转到布尔表达式。
  • 语法

continue 语法是任何循环中一个单独的语句：

1
continue;

  • 示例
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
       public static void main(String args[]) {
          int [] numbers = {10, 20, 30, 40, 50};
          for(int x : numbers ) {
             if( x == 30 ) {
              continue;
             }
             System.out.print( x );
             System.out.print("\n");
          }
       }
    }

条件判断

if语句

  • 示例
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    public class Test {
       public static void main(String args[]){
          int x = 30;
          if( x == 10 ){
             System.out.print("Value of X is 10");
          }else if( x == 20 ){
             System.out.print("Value of X is 20");
          }else if( x == 30 ){
             System.out.print("Value of X is 30");
          }else{
             System.out.print("This is else statement");
          }
       }
    }

if 之后可以使用很多个else。或者使用嵌套。

switch 语句

switch 语句允许一个变量来对一系列值得相等性进行测试。每个值被称为一 case，并且被启动的变量会为每一个 case 检查。

  • 语法
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    switch(expression){
        case value :
           //Statements
           break; //optional
        case value :
           //Statements
           break; //optional
        //You can have any number of case statements.
        default : //Optional
           //Statements
    }

以下规则适用于 switch 语句：

  • 在 switch 语句中使用的变量只能是一个字节，short，int 或 char。
  • 在一个 switch 语句中可以有任何数量的 case 语句。每个 case 后跟着即将被比较的值和一个冒号。
  • 对于 case 的值必须是相同的数据类型作为开关变量，它必须是一个常量或文字。
  • 当被启动了的变量与 case 是相等的，那 case 后的语句将执行，一直到 break 为止。
  • 当达到一个 break 语句，switch 终止，并且控制流跳转到跟着 switch 语句的下一行。
  • 不是每一个 case 需要包含一个 break。如果没有出现 break，控制流将贯穿到后面的 case 直到 break 为止。
  • switch 语句可以有一个可选默认 case ，它必须出现在 switch 的结束处。在执行一项任务时没有任何 case 是真，那默认 case 可被使用。在默认 case 中不需要 break。

后记

以上就是java的基本语法了。内容很少，不必记忆。下面一节，是面向对象编程的内容，是java中最核心的基本理论。好了看完就睡吧:）

给作者买杯咖啡吧。喵~