package innerClasds.scjp.liguoliang.com;

import java.io.Serializable;

public class TestInnerClass {

	private String name = "var+TestName";

	public static void main(String[] args) {
		new TestInnerClass().new InnerClass().printDes();
		new TestInnerClass().testInnerClassInMethod("info");
		TestInnerClass.StaticClass.printInfo();
	}

	/**
	 * 2. Inner class in method.
	 */
	void testInnerClassInMethod(final String info) {
		// In this class, we can get any variable in the outer class, but only can access the final variables in the method.
		// The reason is(from scjp book): can not keep variables(stored in stack) can keep as long as  inner class instance (stored in the heap),
		// so the inner class only access the final variable. 

		// and the class access modifier:  only abstract or final is permitted
		abstract class InnerClassInMethod {
			abstract void printInfo();
		}

		/** 3. Anonymous class;  */
		InnerClassInMethod inMethod = new InnerClassInMethod() {
			void printInfo() {
				System.out.println(InnerClassInMethod.class + TestInnerClass.this.name + "__" + info);
			}
		};

		inMethod.printInfo();
	}

	/**
	 * 1. Normal inner class. can use public, protected, (default), private accessor modifier to control the scope of the class.
	 * @author Li Guoliang
	 *
	 */
	private class InnerClass extends TestInnerClass implements Serializable{
		private static final long serialVersionUID = 1L;
		//always need final, otherwise:
		//  The field s cannot be declared static; static fields can only be declared in static or top level types
		public static final String s = "s";
		void printDes() {
			System.out.println("Inner" + s + " " + TestInnerClass.class);
		}
	}

	/**
	 * 4. Static nested class.
	 * @author Li Guoliang
	 *
	 */
	private static class StaticClass {
		static void printInfo() {
			System.out.println(StaticClass.class);
		}
	}

}

Some comments:

1. Inner Class:

can be public, protected, private, final, abstract, static, strictfp.
need an outer instance to crate the inner instance, like: new TestInnerClass().new InnerClass();
Use outClass.this to get the outer instance;

2. Inner class in method

can be public, protected, private, final, abstract, static, strictfp;
can access any property in the outer instance;
only can access final variable in the method.

3. Anonymous class

4. Static nested class
can be public, protected, private, final, abstract, static, strictfp.

here are some notes when I first learn inner class in java: >>go<<

----------Post from: @LiGuoliang.com, 欢迎回来~----------

	public static void main(String[] args) {
		int x = 10;
		assert x==100:"assertion failed!";
	}

How to determine assertion is enabled or not?

		   boolean isEnable=false;
		   assert isEnable = true;
		   if(isEnable){
		       throw new RuntimeException("Assertion shoule be enable!");
		   }

This is a bad assertion, because it change the value, If assertion is enabled, isEnable will be set to true.

How to enable assertion in Eclipse?

Debug/Run configurations > VM arguments: add “-ea” to enable it or “-da” to disable assertion.

should not used for validate parameter in public method: because anyone can use public method, and can not make sure assertion is enabled or not;

----------Post from: @LiGuoliang.com, 欢迎回来~----------

                                      Object
                                     Throwable
                         Error                    Exception

                                           RuntimeException …..   

There are two types Exception:

1. Checked Exception , we need to declare ‘throws’ in mehtod if there maybe exception be  thrown out, and must be catch or throw it if we use the method.
2. UnChecked exception(RuntimeExcepiton), will be thorwed in runtime, no need to declare them in the method.

1. UnChecked Exception:

public class TestException {
	public void test() throws NullPointerException{
		System.out.println("Test  OK");
	}

	public static void main(String[] args) {
		new TestException().test();
	}
}

output: “Test OK”

2. Checked Exception:

public class TestException {
	public void test() throws IOException{
		System.out.println("Test  OK");
	}

	public static void main(String[] args) {
		new TestException().test(); // Can not compile: surround with try/catch or add throws declaration
	}
}

3. Overriding:

Access modifier can be enlarged, but exception only can be less or specialized.

package scjp.liguoliang.com;

import java.io.FileNotFoundException;
import java.io.IOException;

public class TestException {
	public void test() throws IOException{
		System.out.println();
	}

}

class TestExceptionSub extends TestException {
	public void test() throws FileNotFoundException{ // FileNotFoundException extends IOException

	}
}

This can work fine, but if we let TestExceptionSub to implement an Interface, like:

package scjp.liguoliang.com;

import java.sql.SQLException;

public interface ITestException {

	void test() throws  SQLException;
}

package scjp.liguoliang.com;

import java.io.FileNotFoundException;
import java.io.IOException;

public class TestException {
	public void test() throws IOException{
		System.out.println();
	}

}

class TestExceptionSub extends TestException implements ITestException{
	public void test() throws FileNotFoundException{ //Can not compile!

	}
}

Multiple markers at this line
    – overrides scjp.liguoliang.com.TestException.test
    – Exception FileNotFoundException is not compatible with throws clause in
     ITestException.test()

for test() in TestExceptionSub , If we want to throw any checked exception, we need get the sub class from ‘IOException’ and ‘SQLException’., or just remove throws declaration.

but for un-checked exception, you can throw any, and no matter with the super class declaration.

4. Catch sequence: the specification exception need catched before it’s super exception, otherwise:
“Unreachable catch block for Exception. It is already handled by the catch block for Throwable”

	public static void main(String[] args) {
		try{
			throw new SQLException();
		}catch (SQLException e) {
			System.out.println("SQLException catched!");
			return;
		}catch (Throwable e) {
			System.out.println("Exception Catched!");
			return;
		}
		finally {
			System.out.println("Finally");
		}
	}

----------Post from: @LiGuoliang.com, 欢迎回来~----------

package newjob.guoliang.corejava;

public class ReferenceTypeTest {
	public static void main(String[] args) {
		AClass a = new BClass();
		new ReferenceTypeTest().printClassDesc(a);
	}

	protected void printClassDesc(AClass a) {
		System.out.println("A_" + a.desc);
	}

	protected void printClassDesc(BClass b) {
		System.out.println("B_" + b.desc);
	}

}

class AClass {
	String desc = "ClassA";
}

class BClass extends AClass{
	String desc = "ClassB";
}

Output is:

A_ClassA
MethodClassB_ClassB


----------Post from: @LiGuoliang.com, 欢迎回来~----------

Instance block / variable;

Constructor;

public class StaticTest {
	public static void main(String[] args) {
		// System.out.println(B.a);
		// System.out.println(C.c);
		StaticTest staticTest = new StaticTest();
		staticTest.printName();
	}

	static {
		System.out.println("Static_block_Main");
	}

	public StaticTest() {
		System.out.println("Consturctor_Main");
	}

	private void printName() {
		System.out.println("InstanceMethod");
	}
	{
		System.out.println("Instance_block_Main");
	}

}

Output is:

Static_block_Main
Instance_block_Main
Consturctor_Main
InstanceMethod

----------Post from: @LiGuoliang.com, 欢迎回来~----------

Output

----------Post from: @LiGuoliang.com, 欢迎回来~----------

package scjp.liguoliang.com;

public class Animal {

	private String type = "Dog";
	public String name = "Animal";

	public String getType() {
		return type;
	}

	public void eat() {
		System.out.println(name + ", Animal eat...");
	}
}

package scjp.liguoliang.com;

public class Dog extends Animal {

	private String type = "Dog";
	public String name = "Dog";

	public String getType() {
		return type;
	}

	public void eat() {
		System.out.println(name + ", Dog eat...");
	}
}

And here is the test codes:

	public static void main(String[] args) {
		Dog dog = new Dog();
		Animal animalDog = new Dog(); // New dog, but type is Animal.

		System.out.println(dog.name);
		System.out.println(dog.getType());
		dog.eat();

		System.out.println(animalDog.name);
		System.out.println(animalDog.getType());
		animalDog.eat();

		System.out.println("\nWe are going to test overloading:");
		OverLoadingTest overLoadingTest = new OverLoadingTest();
		overLoadingTest.testEat(animalDog);
		overLoadingTest.testEat(dog);
	}

	public void testEat(Animal animal) {
		System.out.println("Test Animal eat");
	}

	public void testEat(Dog dog) {
		System.out.println("Test Dog eat");
	}

Here is the output:

In summary:

1. overriding: Polymorphism is for instance method, so  an animal type reference to a dog Object will call dog’s method; but for properties, will use animals.

2. overloading: which method will be called has been determined when compiling by the reference type.

----------Post from: @LiGuoliang.com, 欢迎回来~----------

jboss-5.1.0.GA\bin： modify the configuration run.conf.bat(Windows) or run.conf(Linux), remove the comment at the start of the line, and set suspend=n：

(remove: rem or # )set “JAVA_OPTS=%JAVA_OPTS% -Xrunjdwp:transport=dt_socket,address=8787,server=y,suspend=n” 

Start the server;

#2. Debug the project in Eclipse:

----------Post from: @LiGuoliang.com, 欢迎回来~----------

Pattern pattern = Pattern.compile(“\\{C0\\}”);
Matcher matcher = pattern.matcher(“Price: [{C0}].”);
System.out.println(matcher.replaceAll(“€6.99″));
System.out.println(matcher.replaceAll(“$6.99″));
输出:
Price: [€6.99].
Exception in thread “main” java.lang.IndexOutOfBoundsException: No group 6
at java.util.regex.Matcher.group(Unknown Source)
at java.util.regex.Matcher.appendReplacement(Unknown Source)
at java.util.regex.Matcher.replaceAll(Unknown Source)
at TestExcel2Xml.main(TestExcel2Xml.java:10)

可见第一个replaceAll是正常工作的, 但第二个中的美元符号就出问题了.

Java API:
Note that backslashes (\) and dollar signs ($) in the replacement string may cause the results to be different than if it were being treated as a literal replacement string. Dollar signs may be treated as references to captured subsequences as described above, and backslashes are used to escape literal characters in the replacement string.

可以使用Matcher.quoteReplacement(String)对替换内容进行预先处理: (API)
Returns a literal replacement String for the specified String. This method produces a String that will work use as a literal replacement s in the appendReplacement method of the Matcher class. The String produced will match the sequence of characters in s treated as a literal sequence. Slashes (‘\’) and dollar signs (‘$’) will be given no special meaning.

修改为:

Pattern pattern = Pattern.compile(“\\{C0\\}”);
Matcher matcher = pattern.matcher(“Price: [{C0}].”);
System.out.println(matcher.replaceAll(“€6.99″));
System.out.println(matcher.replaceAll(Matcher.quoteReplacement(“$6.99″)));

正确输出:

Price: [€6.99].
Price: [$6.99].

----------Post from: @LiGuoliang.com, 欢迎回来~----------

由于时间有限, 本例仅展示环境配置,  基于Athena Console管理数据结构并自动生成Java, Flex代码,  通过简单编程实现基本功能.

所有的代码均可通过: http://code.google.com/p/athenahelloworld/ checkout(不含lib).

本文分三部分:

1. 基于Athena框架的Flex入门教程(1) 环境配置
2. 基于Athena框架的Flex入门教程(2)配置Entity, 自动生成Java端, Flex端代码
3. 基于Athena框架的Flex入门教程(3) 编写Java Flex两端代码,运行程序

下图为Athena framework官方提供的Test Drive最后效果图, 可进行Employ的CRUD, 并列出Department的所有employ.

----------Post from: @LiGuoliang.com, 欢迎回来~----------