Java基础语法入门

（由于时间原因，本博客将持续更新）

　一、Java简介

　　Java是由Sun Microsystems公司于1995年5月推出的Java面向对象程序设计语言和Java平台的总称。由James Gosling和同事们共同研发，并在1995年正式推出。

Java分为三个体系：

JavaSE（J2SE）（Java2 Platform Standard Edition，java平台标准版）
JavaEE(J2EE)(Java 2 Platform,Enterprise Edition，java平台企业版)
JavaME(J2ME)(Java 2 Platform Micro Edition，java平台微型版)。

　　2005年6月，JavaOne大会召开，SUN公司公开Java SE 6。此时，Java的各种版本已经更名以取消其中的数字"2"：J2EE更名为Java EE, J2SE更名为Java SE，J2ME更名为Java ME。

Java 编程语言的风格十分接近C、C++语言。Java是一个纯的面向对象的程序设计语言，它继承了 C++ 语言面向对象技术的核心，Java舍弃了C ++语言中容易引起错误的指针（以引用取代）、运算符重载、多重继承（以接口取代）等特性，增加了垃圾回收器功能用于回收不再被引用的对象所占据的内存空间，使得程序员不用再为内存管理而担忧。在 Java SE 1.5 版本中，Java 又引入了泛型编程、类型安全的枚举、不定长参数和自动装/拆箱等许多语言特性。

　　语言特点：

　　1. 跨平台性
所谓的跨平台性，是指软件可以不受计算机硬件和操作系统的约束而在任意计算机环境下正常运行。这是软件发展的趋势和编程人员追求的目标。之所以这样说，是因为计算机硬件的种类繁多，操作系统也各不相同，不同的用户和公司有自己不同的计算机环境偏好，而软件为了能在这些不同的环境里正常运行，就需要独立于这些平台。
而在Java语言中， Java自带的虚拟机很好地实现了跨平台性。 Java源程序代码经过编译后生成二进制的字节码是与平台无关的，但是可被Java虚拟机识别的一种机器码指令。 Java虚拟机提供了一个字节码到底层硬件平台及操作系统的屏障，使得Java语言具备跨平台性。

　　2. 面向对象
面向对象是指以对象为基本粒度，其下包含属性和方法。对象的说明用属性表达，而通过使用方法来操作这个对象。面向对象技术使得应用程序的开发变得简单易用，节省代码。Java是一种面向对象的语言，也继承了面向对象的诸多好处，如代码扩展、代码复用等。

　　3. 安全性
安全性可以分为四个层面，即语言级安全性、编译时安全性、运行时安全性、可执行代码安全性。语言级安全性指Java的数据结构是完整的对象，这些封装过的数据类型具有安全性。编译时要进行Java语言和语义的检查，保证每个变量对应一个相应的值，编译后生成Java类。运行时Java类需要类加载器载入，并经由字节码校验器校验之后才可以运行。 Java类在网络上使用时，对它的权限进行了设置，保证了被访问用户的安全性。

　　4. 多线程
多线程在操作系统中已得到了最成功的应用。多线程是指允许一个应用程序同时存在两个或两个以上的线程，用于支持事务并发和多任务处理。 Java除了内置的多线程技术之外，还定义了一些类、方法等来建立和管理用户定义的多线程。

　　5. 简单易用
Java源代码的书写不拘泥于特定的环境，可以用记事本、文本编辑器等编辑软件来实现，然后将源文件进行编译，编译通过后可直接运行，通过调试则可得到想要的结果。

　　二、Java运行原理

　　　　首先介绍Java的开发环境，jdk 为java的开发工具，jvm Java的虚拟机， jre java的运行环境。在编译时，以.java结尾的源代码文件执行javac命令，通过JVM（Java虚拟机）把源文件编译成.class结尾的字节码文件，此字节码文件与平台无关。在运行时，执行Java命令，通过Java虚拟机把字节码文件解释为特定平台能够识别的机器码，从而实现一处编译，出处运行的概念。

　　三、第一个Java文件：实现Hello word！

1 public class Hello{
2     public static void main(String[] args){
3         System.out.println("hello word!");
4     }
5 }

执行代码：

（1）在命令窗体输入： javac 文件名.java

（2）输入：java 文件名

注意：

类名和文件名要保持一致；
Java源代码中的所有标点符号使用英文输入法状态输入；
Java源代码是区分大小写；
类名默认都使用大写；

　　四、标识符

标识符是用于类名、变量名、方法名、对象名、数组名等的命名；
可以使用英文、数字、下划线_、$符号；
不能以数字开头；
不能使用Java关键字或保留字；
区分大小写；

　　五、基本数据类型

　　Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

byte：

byte 数据类型是8位、有符号的，以二进制补码表示的整数；
最小值是 -128（-2^7）；
最大值是 127（2^7-1）；
默认值是 0；
byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
例子：byte a = 100，byte b = -50。

short：

short 数据类型是 16 位、有符号的以二进制补码表示的整数
最小值是 -32768（-2^15）；
最大值是 32767（2^15 - 1）；
Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
默认值是 0；
例子：short s = 1000，short r = -20000。

int：

int 数据类型是32位、有符号的以二进制补码表示的整数；
最小值是 -2,147,483,648（-2^31）；
最大值是 2,147,483,647（2^31 - 1）；
一般地整型变量默认为 int 类型；
默认值是 0 ；
例子：int a = 100000, int b = -200000。

long：

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，Long b = -200000L。
"L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。

float：

float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
float 在储存大型浮点数组的时候可节省内存空间；
默认值是 0.0f；
浮点数不能用来表示精确的值，如货币；
例子：float f1 = 234.5f。

double：

double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数；
浮点数的默认类型为double类型；
double类型同样不能表示精确的值，如货币；
默认值是 0.0d；
例子：double d1 = 123.4。

boolean：

boolean数据类型表示一位的信息；
只有两个取值：true 和 false；
这种类型只作为一种标志来记录 true/false 情况；
默认值是 false；
例子：boolean one = true。

char：

char类型是一个单一的 16 位 Unicode 字符；
最小值是 \u0000（即为0）；
最大值是 \uffff（即为65,535）；
char 数据类型可以储存任何字符；
例子：char letter = 'A';。

　　两种数据类型转换：自动类型转换，强制类型转换

int a = 1;
long b = a;//小类型转大类型，自动类型转换

int a = 127;
byte b =(byte) a;//大类型转小类型，需要强制类型转换

　　六、变量声明与变量类型

　　声明语法：

　　　　数据类型变量名 ;

　　赋值：

　　　　变量名 = 值；

//格式如下：
type identifier [ = value][, identifier [= value] ...] ;

格式说明：type为Java数据类型。identifier是变量名。可以使用逗号隔开来声明多个同类型变量。

声明示例1：

public class Hello{
    
    public static void main(String[] args){
        
        //声明整数类型的a，在内存中创建这个变量

        int a;
        double b;
        double c;
        
        //给变量赋值

        a = 1;
        b = 2;

        System.out.println(a/b);
        
    }

}

声明示例2：

int a, b, c;         // 声明三个int型整数：a、 b、c
int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值
byte z = 22;         // 声明并初始化 z
String s = "runoob";  // 声明并初始化字符串 s
double pi = 3.14159; // 声明了双精度浮点型变量 pi
char x = 'x';        // 声明变量 x 的值是字符 'x'。

　　Java语言支持的变量类型有：类变量（静态变量）、实例变量（成员变量，非静态变量）、局部变量

　　类变量（静态变量）：

类变量也称为静态变量，在类中以 static 关键字声明，但必须在方法之外。
无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。
静态变量除了被声明为常量外很少使用。常量是指声明为public/private，final和static类型的变量。常量初始化后不可改变。
静态变量储存在静态存储区。经常被声明为常量，很少单独使用static声明变量。
静态变量在第一次被访问时创建，在程序结束时销毁。
与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为public类型。
默认值和实例变量相似。数值型变量默认值是0，布尔型默认值是false，引用类型默认值是null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。
静态变量可以通过：ClassName.VariableName的方式访问。
类变量被声明为public static final类型时，类变量名称一般建议使用大写字母。如果静态变量不是public和final类型，其命名方式与实例变量以及局部变量的命名方式一致。

　　实例变量（成员变量、非静态变量）：

实例变量声明在一个类中，但在方法、构造方法和语句块之外；
当一个对象被实例化之后，每个实例变量的值就跟着确定；
实例变量在对象创建的时候创建，在对象被销毁的时候销毁；
实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；
实例变量可以声明在使用前或者使用后；
访问修饰符可以修饰实例变量；
实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；
实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；
实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。

　　局部变量：

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

public class Variable{
    static int allClicks=0;    // 类变量
 
    String str="hello world";  // 实例变量
 
    public void method(){
 
        int i =0;  // 局部变量
 
    }
}

七、运算符

计算机的最基本用途之一就是执行数学运算，作为一门计算机语言，Java也提供了一套丰富的运算符来操纵变量。我们可以把运算符分成以下几组：算术运算，符关系运算符，位运算符，逻辑运算符，赋值运算符，其他运算符。

算数运算符

　　算术运算符用在数学表达式中，它们的作用和在数学中的作用一样。下表列出了所有的算术运算符。表格中的实例假设整数变量A的值为10，变量B的值为20：

重点掌握：取模（%）、自增自减（++a，a++）

示例：

        int a = 1;
        a++;// 自身增加1 ，  a = a; a=a+1
        ++a;// 自身增加1，  a = a+1 ; a = a
        System.out.println(a++); // 在打印的时候，执行的是a = a，所以打印的结果为1 ，打印结束后 a = a+1;
        System.out.println(a);
        
        System.out.println(++a); // 在打印的时候同时执行了 a = a + 1，所以结果为2，打印结束后又执行了 a=a;
        System.out.println(a);

　　2.关系运算符：表格中的实例整数变量A的值为10，变量B的值为20：

　3.赋值运算

　　4.逻辑运算符

　　5.位运算

示例：

        boolean a = 1>2; // false
        boolean b = 1==1;// true
        
        System.out.println(a & b);//短路与
        System.out.println(a | b);//短路或
        
        int a = 3;// 转为二进制：11
        int b = 2;// 转为二进制：10
        
        char a = 'a';// 97 -->  1100001
        char b = 'b';// 98 -->  1100010
                     //         1100000 --> 96
                     //         1100011 --> 99
                     //         0000011 --> 3
        
        System.out.println(a & b);// & 表示对应位都为1，结果为1，否则为0
        System.out.println(a | b);// | 表示对应位都为0，结果为0，否则为1
        System.out.println(a ^ b);// ^ 表示对应位相同，结果符号两边相同时返回false，两边不同时返回true；

　　6.条件运算符

条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。

语法：

变量类型变量名 = 条件？ A ： B ；

解读：

声明一个变量，当条件为true时，当前变量的值为A，当条件为false时，当前变量的值为B；

示例：

public class Test {
   public static void main(String[] args){
      int a , b;
      a = 10;
      // 如果 a 等于 1 成立，则设置 b 为 20，否则为 30
      b = (a == 1) ? 20 : 30;
      System.out.println( "Value of b is : " +  b );
 
      // 如果 a 等于 10 成立，则设置 b 为 20，否则为 30
      b = (a == 10) ? 20 : 30;
      System.out.println( "Value of b is : " + b );
   }
}

运行结果：
Value of b is : 30
Value of b is : 20

　　八、修饰符

Java提供的修饰符主要分为访问修饰符和非访问修饰符

1. 访问控制修饰符：

　　　　Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

default (即缺省，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
public : 对所有类可见。使用对象：类、接口、变量、方法
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

　　2.非访问控制修饰符：

　　　　为了实现一些其他的功能，Java 也提供了许多非访问修饰符。

　static ：，用来修饰类方法和类变量。
　final ：，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
　abstract：，用来创建抽象类和抽象方法。
　synchronized 和 volatile：主要用于线程的编程。

　九、类的声明与实例化

　　类可以看成是创建Java对象的模板。一个类可以包含以下类型变量：

局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
类变量：类变量也声明在类中，方法体之外，但必须声明为static类型。

每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认构造方法。

在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。

　　对象是根据类创建的。在Java中，使用关键字new来创建一个新的对象。创建对象需要以下三步：

声明：声明一个对象，包括对象名称和对象类型。
实例化：使用关键字new来创建一个对象。
初始化：使用new创建对象时，会调用构造方法初始化对象。

　　示例：

public class Puppy{
   int puppyAge;
   public Puppy(String name){
      // 这个构造器仅有一个参数：name
      System.out.println("小狗的名字是 : " + name ); 
   }
 
   public void setAge( int age ){
       puppyAge = age;
   }
 
   public int getAge( ){
       System.out.println("小狗的年龄为 : " + puppyAge ); 
       return puppyAge;
   }
 
   public static void main(String[] args){
      /* 创建对象 */
      Puppy myPuppy = new Puppy( "tommy" );
      /* 通过方法来设定age */
      myPuppy.setAge( 2 );
      /* 调用另一个方法获取age */
      myPuppy.getAge( );
      /*你也可以像下面这样访问成员变量 */
      System.out.println("变量值 : " + myPuppy.puppyAge ); 
   }
}

运行结果：
小狗的名字是 : tommy
小狗的年龄为 : 2
变量值 : 2

　　源文件声明规则：

一个源文件中只能有一个public类
一个源文件可以有多个非public类
源文件的名称应该和public类的类名保持一致。例如：源文件中public类的类名是Employee，那么源文件应该命名为Employee.java。
如果一个类定义在某个包中，那么package语句应该在源文件的首行。
如果源文件包含import语句，那么应该放在package语句和类定义之间。如果没有package语句，那么import语句应该在源文件中最前面。
import语句和package语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。

　　详细讲解：请点击这里

　十、函数声明与使用

　　习惯把函数也叫成方法，都是一个意思；函数是具备特定功能的一段代码块，解决了重复性代码的问题。

　　1.函数的声明：

语法：

[访问修饰符] [static] 返回值类型方法名（参数列表）{

要执行的代码

}

示例：

public static void print(){
        System.out.println("hello");
    }

static关键字

用法：

- 当使用static关键字修饰方法时，该方法称为静态方法，即类的方法；
- 如果没有使用static关键字修饰，该方法为普通方法(实例方法)，即对象的方法；
- 静态方法中，只能直接调用静态方法；
- 实例方法中，可以直接调用静态方法，也可以直接调用实例方法；
- 静态方法中如果要调用实例方法，必须先实例化对象，使用对象名调用；

补充：

实例化对象语法：

类名对象名 = new 类名();

void关键字

- 当方法没有任何返回值时，方法声明语句中使用void关键字；
- 当方法有返回值时，返回值是什么数据类型，就声明为什么类型；

参数

语法：

- 在方法名后面的括号中声明；
- 参数的个数为大于等于0；
- 写法：方法名(类型变量名,类型变量名,……){}
- 参数是当前方法的局部变量，是一种特殊的局部变量；
- 参数的赋值过程，是在调用该方法时完成的；
- 当有多个参数，调用该方法时，依次按照括号中的顺序为参数赋值；
- 参数的类型可以为Java的任何数据类型；

使用函数的好处

（1）提高代码的复用性，减少代码量；

（2）把某个功能封装到一个方法中，便于协作开发；

（3）便于代码集中管理；

（4）提现了面向对象的思想；

重载

概念：重载(overloading) 是在一个类里面，方法名字相同，而参数不同。与返回值类型、访问修饰符无关。

规则：

（1）参数的类型不同；

（2）参数个数不同；

（3）参数的顺序不同；

示例：

import java.util.Scanner;//导入键盘录入的类 Scanner

class Demo_2

{

public static void main(String[] args)

{

Scanner sc=new Scanner(System.in);//创建键盘录入类Scanner的对象

System.out.println("请输入第一个正整数");

int a1=sc.nextInt();//通过对象sc调用Scanner类的nextInt()方法：读取输入的数据并进行存储

System.out.println("请输入第二个正整数");

int a2=sc.nextInt();

System.out.println("请输入第三个正整数");

int a3=sc.nextInt();

int max=getMax(a1,a2,a3);

System.out.println("max="+max);

}

public static int getMax(int x,int y,int z)//获取三个数中的最大值的函数

{

int max;

max=x>y?x:y;//三元运算符的使用

max=max>z?max:z;

return max;

}

运行结果：
请输入第一个正整数
23
请输入第二个正整数
56
请输入第三个正整数
15
max=56

参考详细文章：请点击这里

posted @ 2019-04-22 00:13 浅眸阅读(502) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

浅眸

Java基础语法入门

static关键字

void关键字

参数

使用函数的好处

重载

公告