java基本语法与概念_Java 入门概念梳理之一

Java入门学习

简介

public class HelloWorld {

public static void main(String []args) {

System.out.println("Hello World");

}

}

//输出

// javac将java源文件编译为class字节码文件

$ javac HelloWorld.java

// java后边执行的是java文件的类名，如HelloWorld，注意不要家后缀

$ java HelloWorld

Hello World

Java分三个体系

JavaSE(J2SE/JavaEE)(Java2 Platform Standard Edition，java平台标准版)

JavaEE(J2EE/JavaEE)(Java 2 Platform,Enterprise Edition，java平台企业版)

JavaME(J2ME/JavaME)(Java 2 Platform Micro Edition，java平台微型版)。

特性

简单：和C近，丢弃操作符重载，多继承，自动的强制类型转换，不适用指针而是引用，自动GC

OOP: 提供类，接口和集成，只支持类间继承，支持接口之间多继承并支持类与接口之间的实现机制。

全面支持动态绑定。纯OOP。

分布式的：支持Internet应用开发，在基本Java应用编程接口中有java net

,提供了网络应用变成的类库，包括URL,URLConnection,Socket,ServerSocket等

健壮的：强制型机制、异常处理、垃圾回收，丢弃指针。

安全的：通过网络下载的类具有一个安全防范机制

体系结构中立

可移植的

解释型的

高性能的

多线程的

动态的

基础语法

java程序可认为一系列对象的集合

对象： 类的一个实例，有状态和行为。

类： 类的一个模板，描述一类对象的行为和状态。

方法：行为

实例变量：每个对象都有独特的实例变量，对象的状态由此决定

基本语法

大小写敏感：Java是大小写敏感的，这就意味着标识符Hello与hello是不同的。

类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。

方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。

源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存(切记Java是大小写敏感的)，文件名的后缀为.java。(如果文件名和类名不相同则会导致编译错误)。

主方法入口：所有的Java 程序由public static void main(String []args)方法开始执行。

标识符：类名、变量名以及方法名都被称为标识符

修饰符：修饰类中方法和属性

访问控制修饰符 : default, public , protected, private

非访问控制修饰符 : final, abstract, strictfp

变量

局部变量

类变量(静态变量)

成员变量(非静态变量)

数组：储存在堆上的对象，可以保存多个同类型变量

枚举： 枚举限制变量只能是预先设定好的值。使用枚举可以减少代码中的bug。

注释同JS

继承::::被继承的类称为超类(super class)，派生类称为子类(subclass)。

接口：对象间相互通信的协议。接口在继承中扮演着很重要的角色。

接口只定义派生要用到的方法，但是方法的具体实现完全取决于派生类。

Java 对象和类

Java作为一种面向对象语言。支持以下基本概念：

多态

继承

封装

抽象

类

public class Dog{

String breed;

int age;

String color;

void barking(){

}

void hungry(){

}

void sleeping(){

}

}

对象

public class Puppy{

public Puppy(String name){

//这个构造器仅有一个参数：name

System.out.println("小狗的名字是 : " + name );

}

public static void main(String []args){

// 下面的语句将创建一个Puppy对象

Puppy myPuppy = new Puppy( "tommy" );

}

}

实例

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 );

}

}

方法

public class Puppy{

public Puppy(){

}

public Puppy(String name){

// 这个构造器仅有一个参数：name

}

}

重载

Java packages:对类和接口进行分类。当开发Java程序时，可能编写成百上千的类，因此很有必要对类和接口进行分类。

Import 语句：提供一个合理的路径，使得编译器可以找到某个类。

基本数据类型

内置数据类型(8种)

byte：

byte数据类型是8位、有符号的，以二进制补码表示的整数；

最小值是-128(-2^7)；

最大值是127(2^7-1)；

默认值是0；

byte类型用在大型数组中节约空间，主要代替整数，因为byt- e变量占用的空间只有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。

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’。

引用数据类型

在Java中，引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量 声明时被指定为一个特定的类型，比如Employee、Pubby等。变量一旦声明后，类型就不能被改变了。

对象、数组都是引用数据类型。

所有引用类型的默认值都是null。

一个引用变量可以用来引用与任何与之兼容的类型。

例子：Site site = new Site("Runoob")。

Java常量

自动类型转换：整型、实型(常量)、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。

强制类型转换：

条件是转换的数据类型必须是兼容的。

格式：(type)value type是要强制类型转换后的数据类型 实例：

public class QiangZhiZhuanHuan{

public static void main(String[] args){

int i1 = 123;

byte b = (byte)i1;//强制类型转换为byte

System.out.println("int强制类型转换为byte后的值等于"+b);

}

}

隐含强制类型转换

整数的默认类型是 int。

浮点型不存在这种情况，因为在定义 float 类型时必须在数字后面跟上 F 或者 f

Java变量类型

在Java语言中，所有的变量在使用前必须声明。声明变量的基本格式如下：

type identifier [ = value][, identifier [= value] ...] ;

Java语言支持的变量类型有：

局部变量

局部变量声明在方法、构造方法或者语句块中；

局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；

访问修饰符不能用于局部变量；

局部变量只在声明它的方法、构造方法或者语句块中可见；

局部变量是在栈上分配的。

局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。

成员变量

实例变量声明在一个类中，但在方法、构造方法和语句块之外；

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

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

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

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

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

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

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

实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。

类变量

类变量也称为静态变量，在类中以static关键字声明，但必须在方法构造方法和语句块之外。

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

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

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

静态变量在程序开始时创建，在程序结束时销毁。

与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为public类型。

默认值和实例变量相似。数值型变量默认值是0，布尔型默认值是false，引用类型默认值是null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。

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

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

Java修饰符

修饰符用来定义类、方法或者变量，通常放在语句的最前端

public class className {

// ...

}

private boolean myFlag;

static final double weeks = 9.5;

protected static final int BOXWIDTH = 42;

public static void main(String[] arguments) {

// 方法体

}

访问修饰符

修饰符

当前类

同一包内

子孙类

其他包

public

Y

Y

Y

Y

protected

Y

Y

Y

N

default

Y

Y

N

N

private

Y

N

N

N

非访问修饰符

static 修饰符，用来创建类方法和类变量。

静态变量：

static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。

静态方法：

static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。

final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。

final 变量：

final 变量能被显式地初始化并且只能初始化一次。被声明为 final 的对象的引用不能指向不同的对象。但是 final 对象里的数据可以被改变。也就是说 final 对象的引用不能改变，但是里面的值可以改变。

final 修饰符通常和 static 修饰符一起使用来创建类常量。

final 方法

类中的 final 方法可以被子类继承，但是不能被子类修改。

声明 final 方法的主要目的是防止该方法的内容被修改。

}

final 类

final 类不能被继承，没有类能够继承 final 类的任何特性。

abstract 修饰符，用来创建抽象类和抽象方法

抽象类：

抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。

一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。

抽象方法

抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。

抽象方法不能被声明成 final 和 static。

任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。

如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。

抽象方法的声明以分号结尾，例如：public abstract sample();。

synchronized 和 volatile 修饰符，主要用于线程的编程。

transient 修饰符

volatile 修饰符

volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

一个 volatile 对象引用可能是 null。

Java运算符

算术运算符

关系运算符

位运算符

逻辑运算符

赋值运算符

其他运算符

Java循环结构

while 循环

do…while 循环

for 循环

Java 增强 for 循环

```for(声明语句 : 表达式)

{

//代码句子

}

break 关键字

continue 关键字

Java分支结构

if 语句

switch 语句

Java Number&Math类

所有的包装类(Integer、Long、Byte、Double、Float、Short)都是抽象类 Number 的子类。

Math类同JS

Java Character类

Character 类用于对单个字符进行操作。Character 类在对象中包装一个基本类型 char 的值

char ch = 'a';

// Unicode 字符表示形式

char uniChar = '\u039A';

// 字符数组

char[] charArray ={ 'a', 'b', 'c', 'd', 'e' };

## Java String类

## Java StringBuffer类

> 当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。

和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

## Java Array

### 声明数组变量

dataType[] arrayRefVar; // 首选的方法

dataType arrayRefVar[]; // 效果相同，但不是首选方法

public class TestArray {

public static void main(String[] args) {

// 数组大小

int size = 10;

// 定义数组

double[] myList = new double[size];

myList[0] = 5.6;

myList[1] = 4.5;

myList[2] = 3.3;

myList[3] = 13.2;

myList[4] = 4.0;

myList[5] = 34.33;

myList[6] = 34.0;

myList[7] = 45.45;

myList[8] = 99.993;

myList[9] = 11123;

// 计算所有元素的总和

double total = 0;

for (int i = 0; i < size; i++) {

total += myList[i];

}

System.out.println("总和为： " + total);

}

}

## Java Date(same as JS)

## Java RegExp(same as JS)

## Java Method

System.out.println()，那么它是什么呢？

println() 是一个方法。

System 是系统类。

out 是标准输出对象。

这句话的用法是调用系统类 System 中的标准输出对象 out 中的方法 println()。

/*返回两个整型变量数据的较大值/

public static int max(int num1, int num2) {

int result;

if (num1 > num2)

result = num1;

else

result = num2;

return result;

}

//调用

int larger = max(30, 40);

- void关键字

>一个void方法的调用一定是一个语句。 所以，它被在main方法第三行以语句形式调用。就像任何以分号结束的语句一样。

- 通过值传递参数:调用一个方法时候需要提供参数，你必须按照参数列表指定的顺序提供。

- 重载(JS没有重载但可以模拟)：一个类的两个方法拥有相同的名字，但是有不同的参数列表

Java编译器根据方法签名判断哪个方法应该被调用。

public static double max(double num1, double num2) {

if (num1 > num2)

return num1;

else

return num2;

}

- 变量作用域：程序中变量可以被引用的部分。

>方法的参数范围覆盖整个方法，参数即局部变量，for循环内生命的变量范围从其生命到循环体结束，这点与JS不同

- 命令行参数的使用。

>有时候你希望运行一个程序时候再传递给它消息。这要靠传递命令行参数给main()函数实现。

命令行参数是在执行程序时候紧跟在程序名字后面的信息。

- 构造方法::::当一个对象被创建时，构造方法用来初始化该对象，构造方法和它所在类的名字相同，

但没有返回值。

// 一个简单的构造函数

class MyClass {

int x;

// 以下是构造函数

MyClass(int i ) {

x = i;

}

}

//你可以像下面这样调用构造方法来初始化一个对象：

public class ConsDemo {

public static void main(String args[]) {

MyClass t1 = new MyClass( 10 );

MyClass t2 = new MyClass( 20 );

System.out.println(t1.x + " " + t2.x);

}

}

- finalize方法:在对象被回收前调用，用于清除回收对象。

//你必须指定在对象销毁时候要执行的操作,finalize() 一般格式是：

protected void finalize()

{

// 在这里终结代码

}

public class FinalizationDemo {

public static void main(String[] args) {

Cake c1 = new Cake(1);

Cake c2 = new Cake(2);

Cake c3 = new Cake(3);

c2 = c3 = null;

System.gc(); //调用Java垃圾收集器

}

}

class Cake extends Object {

private int id;

public Cake(int id) {

this.id = id;

System.out.println("Cake Object " + id + "is created");

}

protected void finalize() throws java.lang.Throwable {

super.finalize();

System.out.println("Cake Object " + id + "is disposed");

}

}

## Java Stream,FIle , IO

>Java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。

Java.io 包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等等。

一个流可以理解为一个数据的序列。输入流表示从一个源读取数据，输出流表示向一个目标写数据。

Java 为 I/O 提供了强大的而灵活的支持，使其更广泛地应用到文件传输和网络编程中。

//读取控制台输入

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

//从控制台读取多字符输入

int read( ) throws IOException

- 文件读写

![http://www.runoob.com/wp-content/uploads/2013/12/12-130Q122402I57.jpg][http://www.runoob.com/wp-content/uploads/2013/12/12-130Q122402I57.jpg]

## Java Scanner类:获取用户的输入

import java.util.Scanner;

public class ScannerDemo {

public static void main(String[] args) {

Scanner scan = new Scanner(System.in);

System.out.println("next:");

if(scan.hasNext()){

String str1 = scan.next();

System.out.println("input :"+str1);

}

}

}

## Java unExpect

>异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的

常见三种异常

- 检查型异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，

一个异常就发生了，这些异常在编译时不能被简单地忽略。

- 运行时异常：运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。

- 错误：错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，

一个错误就发生了，它们在编译也检查不到的。

### Exception类的层次

异常类有两个主要的子类：IOException 类和 RuntimeException 类。

---------------------