首页手记 Java 入门概念梳理之一

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

}
}

隐含强制类型转换
1. 整数的默认类型是 int。
2. 浮点型不存在这种情况，因为在定义 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 类。

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

点击查看更多内容