2.1

##################################################

简单认识一下 hello.java 源文件的代码

    hello.java code：
public class hello {
 
    public static void main ( String [] args ) {
 
        System.out.println ( "Hello,World!" );
    }
}

——————————

如何定义一个类

        在这个 .java 文件中只有一个 hello 类：

public class hello { }

        类名前用 public 和 class 修饰 中间用空格隔开

        该类被 public 修饰则 hello 类就代表这个源文件 该文件名必须以这个类名命名

        类名后面跟了一对花括号 所有属于该类的代码都放在后面紧跟的 花括号/{} 中

——————————

程序从 main 方法开始

        程序的起点：

public static void main ( String [] args) { }

        跟 C 一样
        main() 就是程序的入口 所有 Java 程序的起点
        如果没有 main 方法 计算机就不知道在那里开始执行！

一个程序只能有一个 main() ！！！

        编写 main() 时要求固定的格式和内容书写

        前面必须使用 public、static、void 进行修饰 这是必须的 而且顺序不能改变

        main() 后面的花括号就是执行的指令

——————————

输出语句

        向控制台输出一条信息：

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

        System.out.println() 是 Java 语言提供的输出方法

        print 的含义是打印

        ln 可以看作 line 表示行的缩写

        所以 println 就是打印一行

System.out.println();        /* 打印完一行后会进行换行 */

System.out.print();        /* 打印完一行后不会自动换行 继续在该行输出 */

System.out.print("\n");        /* 使用转义字符 '\n' 打印完一行后将光标移动到下一行的第一格 即换行 */

——————————

        下面都是一些扩展知识 如果你是一个有自己想法的人可以刷完

        如果是速成学习请跳下一篇吧！

##################################################

Other

——————————

行代码

        代码必须一句一行 看上去简介漂亮 一目了然

        Java 程序中一句连续的字符串不能分开在两行中写！！

        例如 输出语句

System.out.println ( "我是内容" );

        不能写成：

System.out.println ( "我是

内容" );

        Java 是一种自由格式的语言

        在 Java 中，所有的程序代码分为

结构定义语句
功能执行语句

        一条语句可以写在若干行上
        功能执行语句的最后 必须用分号结束！

;

        其实不需要完全对齐或缩进一致

        可以按照自己的意愿任意编排

        只要每个词之间 用：

空格
制符表
换行符
大括号
小括号

        等分隔符隔开就行

        例如 优美的代码：

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

        偏偏写成神经病的代码风格：

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

        这特么誰能看懂……！

——————————

区分大小写/中英文敏感

        Java 是对大小写敏感的

        例如
标识符 Hello 与 hello
关键字 Class 与 class
        是不同的两个标识符！！！

        严格区分大小写

        不仅区分大小写 还区分中英文！！
        程序语言必须用英文写！！
        一个标点符号错了 你就慢慢找错吧。。
        例如

;        /* 英文分号结尾 通过编译 */
；        /* 中文分号结尾 编译不通过！ */

        分号冒号 千万不要用中文输入法
        编译器通常会报告：

illegal character

        非法字符这样的错误信息

——————————
标识符/identifier

        标

识_四声

        符

        就是指用来标识某个实体的一个符号

        在不同的应用环境下有不同的含义

        在计算机编程语言中 标识符是用户编程时使用的名字
        用于给变量、常量、函数、语句块等命名！
        以建立起名称与使用之间的关系

        标识符通常由字母和数字以及其她字符构成

        在 Java 中对于

变量
常量
函数
语句块

        的名字 通通称之为 Java 标识符！！

        在 Java 中标识符是用来给

类
对象
方法
变量
接口
自定义数据类型

        命名的

        Java 标识符由

数字 1-9
字母 a/A-z/Z
下划线 _
美元符号或人民币符号 $/￥

        组成
        需要注意的是：

区分大小写
第一个绝对不能是数字
不能是关键字/保留字

        标识符命名规则

        类、接口名

每个字的首字母大小 含有大小写
        例如
HelloWorld

        方法名
        一般都是 驼峰命名法/CamelCase
首字符小写
其余首字母大写
含大小写 尽量少用下划线
    例如
myTime

        常量名
基本数据类型的常量名使用全部大写字母
字与字之间 用下划线分隔
对象常量可大小混写
        例如：
MY_NAME

        变量名
可大小写混写 首字符小写
字间分隔符用字的首字母大写
不用下划线 少用美元符
给定的名字一定要见名知意

——————————
关键字/keyword

        关键字 就是电脑语言里事先定义的、有特别意义的标识符
        又称之为 保留字/Reserved word

        还有特别意义的变量

有的与数据类型相关 例如 int
有的与流程控制相关 例如 if

        Java 中的关键字 对 Java 编译器来说有特殊的意义

        她们用来表示一种数据类型或者表示程序的结构等
        关键字不能作为以下这些来使用：

变量名
方法名
类名
包名
参数

        开头示例的 hello 中的的

class

        就是说 声明一个类

public class hello

        就是说 声明一个叫 hello 的公共类

——————————

空白符与空白行

        如果一行都是空格 被称为空白行 编译时会完全忽略她

        空格用于描述空白符、制表符、换行符和注释。

        空格分隔语句的各个部分

        让编译器能识别语句中的某个元素在哪里结束 下一个元素在哪里开始

        例如:

int a;

        中

int

        和

a

        之间必须至少有一个空格字符 通常是一个空白符
        这样编译器才能够区分她们

        例如：

a = a + b;

        a 和 = 或者 = 和 a 之间没有必要有空格字符
        但是为了增强可读性可以根据需要适当增加一些空格

——————————
类型修饰符/TypeSpecifier

        public 意思很明确：

公共的/公开的

        她是一个修饰符

        public 就是说：

谁都能访问的 谁都能访问被她修饰的成员

        而相对的是 私有的：

private

        就是说 只有本类中的成员才可以访问被她修饰的！
        很安全 也很讨厌。。

        什么叫类型修饰符：

用于限定类型以及类型成员的声明的一种符号

    类修饰符：
default    默认类
public    公共类
private    私有类
abstract    抽象类
static    静态类
fanal    不能被继承的类

        我们现在只需要有个概念即可 这里先引入一些概念 混个眼熟

        不过还是要说一下这个默认类 default
        关键字 class 前面什么都不加 就是默认了
        例如：

class 类名 { }

        这是可以的 不会报错：

——————————
类名规范

        关于类名
        对于所有的类来说，类名的首字母应该大写
        如果类名由若干单词组成那么每个单词的首字母应该大写
        不是因为什么必须的格式要求 完全是为了可读性

        如果类名是一个名词 应该采用大小写混合的方式
        即每一个单词的首字母大写
        例如：

Test

        类的名字必须是大写字母开头 而单词中的其他字母均小写
        例如：

First

        如果类名由多个单词组成 则每个单词的首字母均大写
        例如：

HelloWorld

        如果类名称中包含单词所写 则缩写词的每一个字母均大写
        例如 HelloWorldFirstTest 缩写为 ：

HWFirstTest        /* 第一个 HelloWorld 实验 */

        文件名 要和 类名 一样 包括大小写 这几乎是公认的：

源文件名必须和类名相同

        当保存文件的时候 你应该使用类名作为文件名保存
        切记 Java 是大小写敏感的 文件名的后缀为

.java

        如果文件名和类名不相同 可能会导致编译错误

——————————

方法名规范

        方法名

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

——————————
花括号/{}

        花括号的作用就是：

强制表示被其包含的代码视为一个整体

        俗称

语句块

代码块

代码体

        例如

类名后的花括号 表示这段代码组成这个类
方法名后的大括号 表示这段代码组成了这个方法
for、while 循环、if 判断 等后面的花括号是一个道理的

        其她地方的花括号作用类似 强制表示结构
        代表一个作用范围
        出了这个范围 就不是我的作用域了

    关于输入方式
    别蠢萌萌先输入一个花括号：
public class hello {

    编写好代码后:
public class hello {
    /* XXX */

    再输入另一个:
public class hello {
    /* XXX */
}

    我们都是 先输入
public class hello { }

    然后回车！：
public class hello{
    /* XXX */
}

    这样比较方便 懒还是要偷的

——————————
注释/notes

        为程序添加注释可以提高程序的可读性
        她是写在程序里的信息 用来说明某段程序的作用和功能

        Java 里的注释根据不同的用途分为三种类型:

单行注释
多行注释
文档注释

%%%%%

        单行注释
        就是在注释内容前面加双斜线

//

        Java 编译器会忽略掉这部分信息
        示例:

int c = 0;        // 定义一个整型

        这是最常用的注释 后面的这一行 都是注释
        如果说明性的文字较少 只用一行 就用这个了

%%%%%

        多行注释
        就是在注释内容前面以单斜线加一个星形标记

/*
        开头,并在注释内容末尾以一个星形标记加单斜线
*/
        结束 例如：
/* int a = 1;        // 定义一个整型
   int b = 2;        // 再定义一个整型 */

        当注释内容超过一行时一般使用这种方法

        为了美观 有的程序风格是这样的：

/*
 * int a = 1;        // 定义一个整型
 * int b = 2;        // 再定义一个整型
 */

        每一行都加一个 星字符
        只是为了美观 并不影响程序

%%%%%

        文档注释

        以单斜线加两个星形标记
/**
    开头
    并以一个星形标记加单斜线
*/
        结束

        用这种方法注释的内容会被解释成程序的正式文档
        并能被包含在诸如 javadoc 之类的工具程序提取的文档里
        用以说明该程序的层次结构及其方法

        前面两种已经够用了 文档注释就不要深入了

/* */
        中可以嵌套
// 
        注释
        但不能嵌套
/* */

        例如 这样就不行：

/*
        /* int a = 1; */
        int b = 2;
*/

——————————

代码风格

        不得不说 我们要从开始就养成良好的编程风格！

        软件编码规范中说

可读性第一
效率第二

        不是没有道理的

        在程序中必须包含适量的注释 以提高程序的可读性和易于维护性
        程序注释一般占程序代码总量的 20% 到 50%

        一个软件在开发和使用过程中
        80 % 的时间是花费在维护上的
        所以编码维护对程序员来说 非常重要

        最起码要做到：

该单独占一行的占一行 最好一行就一段语句
难以理解的就加注释
类名 必须用 public 修饰
低一层次的语句 最好比高一层次的语句或注释 缩进 使得程序更加清晰 可读性更强 更美观
花括号 {} 最好都占一行 并且对齐

——————————

BUG

        程序开发存在一条定律：

一定会出错

        俗称 BUG

        一些常见错误：

类不能随便改名 因为 public 修饰类的名称必须与 java 文件相同
void 不可少 main() 中的 void 不可少
java 对英文字母大小写很敏感
; 是必需的 一个完整的语句都要以英文分号结束
" 是必需的 输出的字符必须用引号引起来 必须是英文的引号

——————————

程序入口

        一个程序只能有一个 main()

        跟 C 一样所有的 Java 程序由 main 方法开始执行：

    C 语言：
main ( void ) {

	/* ... */
}

    Java 语言：
public static void main ( String [] args) {

	/* ... */
}

        编写 main() 的时候 必须按照指定格式：

main 方法前面使用 public、static、void 修饰
她们都是必需的 而且顺序不能变动！
中间同样用空格分隔

        main() 小括号中的代码绝对不能少

String [] args

        main() 后面的花括号就是我们暂时的活动范围了
        我们暂时只能在 main() 中编写程序

        同 C 一样
        Java 的 main() 也有很多种形式

        不过 只有一种声明：

权限修饰符 静态修饰符 方法名 方法的参数类型 ( 参数 ) {  }

        示例：

public static void main ( String [] args ) { }

        前面这一段是一成不变的：

public static void main    

        args 只是一个参数名称 即使把 args 换成其她名称也可以

        因为这个参数是一个字符串数组 这个字符串数组可以随意命名

         只要是一个正确的字符串数组就可以！

main ( String[] LH )
main ( String ljj[] )

        就是说 这几个其实是一样的：

public static void main ( String[] args ) { }
public static void main ( String []args ) { }
public static void main ( String[] args ) { }
public static void main ( String args[] ) { }

        都表示字符串数组 args
        args 真的只是一个普通变量名 随意定义 当然 必须符合变量名规则

        main 方法必须为字符串数组

(String [])

        变量名随意 通常都是 args
        即：

arguments/参数的复数形式

        别奇怪为什么非要这么写 这是 Java 规定的
        如果不这样写 就识别不出主方法 会报错找不到 main 方法

%%%%%

方法重载

        这里说一个超出当前局限的用法 看看就好

        方法重载是指在一个类中定义多个同名的方法

        但要求每个方法具有不同的参数的类型或参数的个数。

        调用重载方法时 Java 编译器能通过检查调用的方法的参数类型和个数选择一个恰当的方法

        方法重载通常用于创建完成一组任务相似但参数的类型或参数的个数或参数的顺序不同的方法

        如果已经有了一个 main() 再有一个同名的 main 方法 就是方法重载了：

public static void main ( String[] args) {


        /* 标准 main() */
}

public static void main ( String args ) {


        /* 方法重载 */
}

        如果有功能类似的方法 可以使用相同的名字来定义不同功能的方法

        方法的名字必须相同，作用域必须相同

        参数必须不同 即便是数量、类型、顺序的不同 只要有一个不同，就是重载方法

        不用为了对不同的参数类型或参数个数，而写多个函数。

        多个函数用同一个名字，但参数表，即参数的个数或数据类型可以不同

        调用的时候，虽然方法名字相同，但根据参数表可以自动调用对应的函数。

        示例：

class A {

	void test() {
		System.out.println ( "1" );
	}
	
	void test( int a ) {
	
		System.out.println ( "a: " + a );
	}
}

        方法重载的主要好处就是不用为了对不同的参数类型或参数个数，而写多个函数。

        多个函数用同一个名字，但参数表，即参数的个数或(和)数据类型可以不同

        调用的时候，虽然方法名字相同，但根据参数表可以自动调用对应的函数。

        如果我们使用 reflector 去查看微软写的 .net 基类库的话

        我们可以发现她使用很多的方法重载

        这样我们在调用的时候，就不需要记那么多的方法名称

        而是知道了方法的功能就可以直接的给他传递不同的参数

        编译器会明确的知道我们调用了哪一个方法

        重载比 if-else 要优雅，减少了 if-else 部分的代码

        重载的最直接作用是方便了程序员可以根据

不同的参数个数、顺序、类型

        自动匹配方法，减少写过个函数名或方法名的重复步骤。

        更直接的示例：

public class main {

   public static void main( String args[] ) {

        A ob=new A();    /* 初始化对象 */

        ob.test();    /* 定义 test() 方法 */
        ob.test(10);    /* 定义 test( int a ) 方法 */
        ob.test(10,20);    /* 定义 test( int a,int b ) 方法 */
        double result=ob.test(123.23);    /* 定义 test( double a ) 方法 */

        System.out.println ( "result of ob.test(123.23): "+result );   /* 输出 result 的值 */
   }
}

class A {
 
    void test() {
    /* test() 第一次重载，没有参数 */

        System.out.println ( "No parameters." );
    }
 
    void test( int a ) {
    /* test() 第二次重载，一个整型参数 */

        System.out.println ( "a: " + a );
    }
 
    void test( int a, int b ) {
    /* test() 第三次重载，两个整型参数 */

        System.out.println ( "a and b: " + a + " " + b );
    }

    double test(double a) {
    /* test() 第四次重载，一个双精度型参数 并且返回 a*a 的值 */

        System.out.println ( "double a: " + a );
        return a * a;
    }
}

        运行结果：

——————————

main() 参数作用

        既然连重载都说出来了 就再深入一下这个参数的作用吧
        对于萌新来说 确实超题了 不求理解 看看就好：

public class main {

    public static void main( String[] args ) {


        for( int i=0; i

	debian 10 demo： 
root@Debian:/work/5.Java/3.Test# java main.java one two three 4
one
two
three
4
root@Debian:/work/5.Java/3.Test# 

    cmd demo：
C:\>javac main.java

C:\>java main 1 2 three
1
2
three

class main {

	public static void main ( String ... args) {



		for( int i=0; i

C:\Users\byme\javaTest>javac main.java

C:\Users\byme\javaTest>java main 1
1

C:\Users\byme\javaTest>java main 1 2 3 a b c !
1
2
3
a
b
c
!

C:\Users\byme\javaTest>

C:\Users\byme\javaTest>type TestMainMethod.java
\u0070\u0075\u0062\u006c\u0069\u0063\u0020
\u0063\u006c\u0061\u0073\u0073\u0020
\u0054\u0065\u0073\u0074\u004d\u0061\u0069\u006e\u004d\u0065\u0074\u0068\u006f\u
0064
\u0020\u007b\u000a\u0070\u0075\u0062\u006c\u0069\u0063\u0020
\u0073\u0074\u0061\u0074\u0069\u0063\u0020
\u0076\u006f\u0069\u0064\u0020
\u006d\u0061\u0069\u006e\u0028\u0053\u0074\u0072\u0069\u006e\u0067\u005b\u005d\u
0020
\u0061\u0072\u0067\u0073\u0029\u0020
\u007b\u000a
\u0053\u0079\u0073\u0074\u0065\u006d\u002e
\u006f\u0075\u0074\u002e
\u0070\u0072\u0069\u006e\u0074\u006c\u006e\u0028\u0022\u0048\u0069\u0022\u0029\u
003b
\u007d\u000a
\u007d\u000a
C:\Users\byme\javaTest>javac TestMainMethod.java

C:\Users\byme\javaTest>java TestMainMethod
Hi

C:\Users\byme\javaTest>