你好，世界！
源代码组织方式
Java程序由package+class组成，package对应目录的相对路径，class对应文件，如
E:\Workspaces\MyEclipse 10\JavaStudy\src\com\happyframework\javastudy\hello\Hello.java
packagecom.happyframework.javastudy.hello;public final classHello {public static voidhello(){
System.out.println("hello!");
}
}
关于class有如下几点规则：
文件的名字必须和class的名字一致(public级别的class名字)。
文件必须只包含一个public访问基本的class(可以包含多个非public级别的class)。
package名字必须和目录一致。
入口方法
App.java
public classApp {public static voidmain(String[] args) {
com.happyframework.javastudy.hello.Hello.hello();
}
}
最终的项目结构
数据类型
8种原子类型
整数类型：byte、short、int和long。
小数类型：float和double。
字符类型：char。
布尔类型：bool。
除此之外的是interface、class和array。
小数类型的常量默认是double类型，声明float类型的常量需要使用F作为后缀。
public classProgram {/***@paramargs*/
public static voidmain(String[] args) {float age = 28.0F;
System.out.println(age);
}
}
运算符
算术运算符：+、-、*、/ 和 %，两个整数相除，结果还是整数。
赋值运算符：=、+=、-=、*=、/=、%=、&=、|=、~=、^=、<<=、>>= 、 >>>=、++ 和 --。
比较运算符：==、!=、 和 >=。
逻辑运算符：&&、|| 和 !。
位运算符：&、|、~、^、<> 和 >>>。
字符串
String是拥有“值语义”的引用类型，字符串常量实现了“享元模式”，equals会按照内容进行比较，==按照地址比较。
public classProgram {/***@paramargs*/
public static voidmain(String[] args) {
String x= "段光伟";
String y= new String("段光伟");
System.out.println(x.equals(y));//true
System.out.println(x == y); //false
}
}
为了高效的修改字符串Java引入了StringBuffer。
{
StringBuffer sb=
newStringBuffer()
.append("段")
.append("光")
.append("伟");
System.out.println(sb.toString());
}
数组
声明语法
DataType[] name 或 DataType name[]。
初始化语法
DataType[] name = new DataType[length]。
DataType[] name = new DataType[] { element1, element2, ...elementn }。
DataType[] name = { element1, element2, ...elementn }。
public classProgram {/***@paramargs*/
public static voidmain(String[] args) {
{
String[] strs= { "段", "光", "伟"};for(String item : strs) {
System.out.print(item);
}
}
}
}
多维数组
只有不等长多维数组DataType[][]，没有DataType[xxx, xxx]。
控制结构
条件：if-else if-else、switch-case-default和三元运算符(?:)。
循环：while、do-while、for和foreach。
Labeled block。
public classProgram {/***@paramargs*/
public static voidmain(String[] args) {
task: {int age = 25;
System.out.println("start");if (age < 30) {breaktask;
}
System.out.println("end");
}
}
}
最近觉得label是个不错的东西，最起码多了一种选择。
方法
Java中所有的赋值和方法调用都是“按值“处理的，引用类型的值是对象的地址，原始类型的值是其自身。
Java支持变长方法参数。
public classProgram {/***@paramargs*/
public static voidmain(String[] args) {
print("段光伟", "段光宇");
print(new String[] { "段光伟", "段光宇"});
}private static voidprint(String... args) {for(String item : args) {
System.out.println(item);
}
}
}
类
public classProgram {/***@paramargs*/
public static voidmain(String[] args) {
Point point= new Point(100);
System.out.print(point);
}
}classPoint {private int x = 0;private int y = 0;public Point(int x, inty) {this.x =x;this.y =y;
}public Point(intx) {this(x, x);
}publicString toString() {return "(x:" + this.x + ",y:" + this.y + ")";
}
}
注意：调用自身的构造方法是用this(xxx,xxx,...)来完成，且必须位于第一行。
静态成员
Java中类似静态构造方法的结构，称之为：静态初始化代码块，与之对应的是实例初始化代码块，见下例：
public classProgram {/***@paramargs*/
public static voidmain(String[] args) {
System.out.println(Point.getValue());
System.out.println(newPoint());
}
}classPoint {private static int value = 0;public static intgetValue() {returnvalue;
}static{
value++;
}static{
value++;
}private int x = 0;private int y = 0;
{this.x = 10;
}
{this.y = 10;
}publicString toString() {return "(x:" + this.x + ",y:" + this.y + ")";
}
}
继承
继承使用 extends，抽象类和抽象方法使用abstract声明，向下转型使用 (ChildType)instance，判断是否是某个类型使用 instanceof，见下例：
public classProgram {/***@paramargs*/
public static voidmain(String[] args) {
printAnimal(newAnimal());
printAnimal(newDog());
}private static voidprintAnimal(Animal animal) {if(animal instanceofDog){
System.out.println("I am a " +(Dog) animal);
}else{
System.out.println("I am an " +animal);
}
}
}classAnimal {publicString toString() {return "Animal";
}
}class Dog extendsAnimal {publicString toString() {return "Dog";
}
}
重写
Java中的重写规则比较灵活，具体如下：
除了 private 修饰之外的所有实例方法都可以重写，不需要显式的声明。
重写的方法为了显式的表达重写这一概念，使用 @Override进行注解。
重写的方法可以修改访问修饰符和返回类型，只要和父类的方法兼容(访问级别更高，返回类型更具体)。
可以使用final将某个方法标记为不可重写。
在构造方法中使用 super(xxx, xxx)调用父类构造方法，在常规实例方法中使用 super.method(xxx, xxx)调用父类方法。
Java不支持覆盖(new)。
public classProgram {/***@paramargs*/
public static voidmain(String[] args) {
Animal animal= newAnimal();
Animal dog= newDog();
animal.say();
dog.say();
animal.eat(animal);
dog.eat(dog);
System.out.println(animal.info());
System.out.println(dog.info());
}
}classAnimal {private String name = "Animal";protected voidsay() {
System.out.println("Animal" + " " + this.name);
}public voideat(Animal food) {
System.out.println("Animal eat " +food);
}publicObject info() {return "Animal";
}
@OverridepublicString toString() {return "Animal";
}
}class Dog extendsAnimal {private String name = "Dog";
@Overridepublic final voidsay() {
System.out.println("Dog" + " " + this.name);
}
@Overridepublic final voideat(Animal food) {super.eat(food);
System.out.println("Dog eated");
}
@Overridepublic finalString info() {return "Dog";
}
@Overridepublic finalString toString() {return "Dog";
}
}
包
包的名字和项目路径下的目录路径相对应，比如：项目路径为：C:\Study，有一个Java源文件位于：C：\Study\com\happyframework\study\App.java，那么App.java的包名字必须为：com.happyframework.study，且 App.java 的第一行语句必须为：package com.happyframework.study。
Java支持三种导入语法：
导入类型：import xxx.xxx.xxxClass。
导入包：import xxx.xxx.xxx.*。
导入静态成员：import static xxx.xxx.*。
import static util.Helper.*;public classProgram {/***@paramargs*/
public static voidmain(String[] args) {
puts("段光伟");
}
}
访问级别
Java支持四种访问级别：public、private、protected 和 default(默认)，类型和接口只能使用public 和 default，成员和嵌套类型可以使用所有，下面简单的解释一下 protected 和 default。
protected 修饰过的成员只能被自己、子类和同一个包里的(不包括子包)其他类型访问。
default 修改过的类型或成员只能被自己和同一个包里的(不包括子包)其他类型访问。
嵌套类
Java支持如下几种嵌套类：
nested class，定义在类型内部的类型。static nested class，使用 static 声明的 nested class，static nested class 可以访问所有外部类的静态成员。
inner class，没有使用 static 声明的 nested class，inner class 可以访问所有外部类的实例成员，inner class 不能定义静态成员。
代码示例
public classProgram {/***@paramargs*/
public static voidmain(String[] args) {
OuterClass outer= newOuterClass();
OuterClass.InnerClass inner= outer.newInnerClass();
OuterClass.InnerClass.InnerInnerClass innerInner= inner.newInnerInnerClass();
outer.show();
inner.show();
innerInner.show();
OuterClass.StaticNestedClass staticNested=newOuterClass.StaticNestedClass();
OuterClass.StaticNestedClass.StaticNestedNestedClass staticNestedNested=newOuterClass.StaticNestedClass.StaticNestedNestedClass();
staticNested.show();
staticNestedNested.show();
}
}classOuterClass {int x = 1;static int i = 1;voidshow() {
System.out.println(x);
System.out.println(i);
}classInnerClass {int y = 2;voidshow() {
System.out.println(x);
System.out.println(y);
}classInnerInnerClass {int z = 3;voidshow() {
System.out.println(OuterClass.this.x);
System.out.println(y);
System.out.println(z);
}
}
}static classStaticNestedClass {static int j = 2;voidshow() {
System.out.println(i);
System.out.println(j);
}static classStaticNestedNestedClass {static int k = 3;voidshow() {
System.out.println(i);
System.out.println(j);
System.out.println(k);
}
}
}
}
特殊的inner class：local class
public classLocalClassExample {static String staticValue = "static value";
String instanceValue= "instance value";public voidtest() {final String finalLocalValue = "final local value";classLocalClass {voidtest() {
System.out.println(staticValue);
System.out.println(instanceValue);
System.out.println(finalLocalValue);
}
}
LocalClass local= newLocalClass();
local.test();
}
}
除了inner class的规则之外，local class可以访问局部final变量，在Java8中有更多的改进。
特殊的local class：anonymous class
public classProgram {/***@paramargs*/
public static voidmain(String[] args) {
execute(newAction() {
@Overridepublic voidexecute() {
System.out.println("执行业务逻辑");
}
});
}static voidexecute(Action action) {
System.out.println("事物开始");
action.execute();
System.out.println("事物结束");
}
}interfaceAction {voidexecute();
}
常量
不废话了，直接看代码：
public final classProgram {static final String STATIC_CONSTANTS = "STATIC_CONSTANTS";final String INSTANCE_CONSTANTS = "INSTANCE_CONSTANTS";public static voidmain(String[] args) {final String LOCAL_CONSTANTS = "LOCAL_CONSTANTS";
System.out.println(STATIC_CONSTANTS);
System.out.println(newProgram().INSTANCE_CONSTANTS);
System.out.println(LOCAL_CONSTANTS);new Program().test("PARAMETER_CONSTANTS");
}public final void test(finalString msg) {
System.out.println(msg);
}
}
有一点需要注意的是：只有一种情况Java的常量是编译时常量(编译器会帮你替换)，其它情况都是运行时常量，这种情况是：静态类型常量且常量的值可以编译时确定。
接口
Java的接口可以包含方法签名、常量和嵌套类，见下例：
public final classProgram {public static voidmain(String[] args) {
Playable.EMPTY.play();newDog().play();
}
}interfacePlayable {
Playable EMPTY= newEmptyPlayable();voidplay();class EmptyPlayable implementsPlayable {
@Overridepublic voidplay() {
System.out.println("无所事事");
}
}
}class Dog implementsPlayable {
@Overridepublic voidplay() {
System.out.println("啃骨头");
}
}
枚举
Java枚举是class，继承自java.lang.Enum，枚举中可以定义任何类型可以定义的内容，构造方法只能是private或package private，枚举成员会被编译器动态翻译为枚举实例常量，见下例：
public final classProgram {public static voidmain(String[] args) {
System.out.println(State.ON);
System.out.println(State.OFF);for(State item : State.values()) {
System.out.println(item);
System.out.println(State.valueOf(item.name()));
}
}
}enumState {
ON(1), OFF(0);int value = 1;
State(intvalue) {this.value =value;
}
}
调用枚举的构造方法格式是：常量名字(xxx, xxx)，如果构造方法没有参数只需要：常量名子，如：
enumState {
ON, OFF
}
异常
Java中的异常分为checked和unchecked，checked异常必须声明在方法中或被捕获，这点我觉得比较好，必定：异常也是API的一部分，见下例：
public final classProgram {public static voidmain(String[] args) {try{
test();
}catch(Exception e) {
System.out.println(e.getMessage());
}
}public static void test() throwsException {throw new Exception("I am wrong!");
}
}
所有继承Exception的异常(除了RuntimeException和它的后代之外)都是checked异常。
装箱和拆箱
Java提供了原始类型对应的引用类型，在1.5之后的版本还提供了自动装箱和自动拆箱，结合最新版本的泛型，几乎可以忽略这块。
import java.util.*;public final classProgram {public static voidmain(String[] args) {
ArrayList list= newArrayList();
list.add(1);int item1 = (Integer) list.get(0);
System.out.println(item1);
}
}
注意：自动装箱和自动拆箱是Java提供的语法糖。
泛型
Java的泛型是编译器提供的语法糖，官方称之为：类型参数搽除，先看一下语法，然后总结一点规律：
泛型方法
测试代码
static voidputs(T msg) {
println(msg);
}static voidprintln(Object msg) {
System.out.println("Object:" +msg);
}static voidprintln(String msg) {
System.out.println("String:" +msg);
}
调用泛型方法
System.out.println("generic method test");
puts("hello");
Program. puts("hello");
输出的结果是
generic method test
Object:hello
Object:hello
泛型类
测试代码
class TestGenericClass{
T value;voidsetValue(T value) {this.value =value;
}
}
调用代码
1 System.out.println("generic class test");2 System.out.println(t.value);
输出结果
1 generic class test
2 1
泛型接口
测试代码
interface TestInterface{voidtest(T item);
}class TestInterfaceImp1 implements TestInterface{
@Overridepublic voidtest(String item) {
System.out.println(item);
}
}class TestInterfaceImp2 implements TestInterface{
@Overridepublic voidtest(T item) {
System.out.println(item);
}
}
调用代码
System.out.println("generic interface test");
TestInterface testInterface1 = newTestInterfaceImp1();
testInterface1.test("hi");for(Method item : testInterface1.getClass().getMethods()) {if (item.getName() == "test") {
System.out.println(item.getParameterTypes()[0].getName());
}
}
TestInterface testInterface2 = new TestInterfaceImp2<>();
testInterface2.test("hi");for(Method item : testInterface2.getClass().getMethods()) {if (item.getName() == "test") {
System.out.println(item.getParameterTypes()[0].getName());
}
}
输出结果
generic interfacetest
hi
java.lang.String
java.lang.Object
hi
java.lang.Object
类型参数约束
测试代码
classAnimal {
}class Dog extendsAnimal {
}class Base{public voidtest(T item) {
System.out.println("Base:" +item);
}
}class Child extends Base{
@Overridepublic voidtest(Dog item) {
System.out.println("Child:" +item);
}
}
调用代码
System.out.println("bounded type parameters test");
Base base = newChild();
base.test(newDog());for(Method item : base.getClass().getMethods()) {if (item.getName() == "test") {
System.out.println(item.getParameterTypes()[0].getName());
}
}
输出结果
1 bounded type parameters test
2 Child:Dog@533c2ac3
3 Dog
4 Animal
81
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
