a> 在一个类中定义一个类，这个类就叫做内部类或者内置类(inner class).
b> 内部类可以让我们将逻辑上相关的一组类组织起来，并由外部类(outer class)
   来控制内部类的可见性.
c> 当我们建立一个inner class的时候,其对象就拥有了与外部类对象之间的一种关系,
   这是通过一个特殊的this inference形成的，使得内部类对象可以随意的访问外部
   类中的所有成员。
d> 在内部类中可以访问外部类的私有成员变量，也就是在内部类中可以随意的访问
   外部类中的所有的成员方法和变量
e> 可以把内部类放到一个方法中来定义，但是它的使用范围必须是在这个方法里
f> 当我们在一个方法中定义一个内部类时，如果我们需要在方法中内部类去访问这个
   本地变量（方法中声明的变量）时，我们必须把这个变量声明为final才行，不然
   编译器会报错
eg:
 void fn(int final a)
 {
  if(true)
  {
   class Middle
   {
    private int index=70;
    class Inner
    {
     private int index=60;
     void print()
     {
      int index=80;
      System.out.println(index);  //访问print()方法中的index=80变量
      System.out.println(this.index); //访问Inner类的成员变量index=60;
      System.out.println(Middle.this.index); //访问Middle类的成员变量index=70;
      System.out.println(Outer.this.index);  //访问Outer类的成员变量index=100;
     }
    }
   }
  }
 }
f> 对于Inner类的访问权限我们可以声明为所有的(protected,private,public,default)。
h> 对于内部类来说，如果起访问权限为protected，那么他可以在同一个类被访也可以在同
   一个包中被访问。而如果声明为private的那么那只能在Outer这个外部类被访问。我们
   可以把它生命为abstract(这个时候不能用Inner直接去实例化一个内部类)，我们可以在
   外部类中定义一个类，从Inner派生出来，直接实例化。当我们声明为final，那就不能再
   派生了，对于内部类来说还可以声明为static，那么这个时候就可以不需要同时存在外部
   类的对象，那么这个时候我们也不能访问外部类的非静态的成员变量和方法。相当于切断
   了与外部内对象的联系。非静态的内部类不能在内部类本身中定义静态的方法(反之可以)。
   非static的内部类中的成员变量不能声明为static的，只在顶层类或static的内部类中可以
   声明为static的。
g> 为什么要使用内部类？
   1.在内部类(inner class)中可以随意访问外部类中的成员，让我们更好的管理和组织我们
   的代码。增强代码的可读性。
   2.内部类用于创建适配器类,适配器类是用于实现接口的类，使用内部类来实现接口，可以
   更好的定位与接口关联的方法在代码中的位置。
   3.其他的用法
   a> 我们可以通过把内部类声明为private来隐藏接口的实现细节
   b> 我们需要派生一个类，同时又需要去实现一个接口，如果基类中有个方法和接口中的方法
   同名，但是他们的用法不一样，我们就可以用内部类来解决。
=============================================================================

内部类的一般用法:
class Outer            //Outer class
{
 private int index=100;  //私有的变量
 /*
 class Inner           //Inner Class,independence individual
 {                     //可以整体的把Inner类看成是Outer类的一个成员
  private int index=50;
  void print()
  {
   int index=30;
   System.out.println(index);
   System.out.println(this.index);
   System.out.println(Outer.this.index);
  }
 }*/
 /*
 *Inner类不管嵌套层次有多深，都可以随意的访问外部的成员变量
 *当我们在一个方法中定义一个内部类时，如果我们需要在方法中内部类去访问这个
  *本地变量（方法中声明的变量）时，我们必须把这个变量声明为final才行，不然
  *编译器会报错
 void fn(final int a)
 {
  final int b=1;
  if(true)
  {
   class Middle
   {
    private int index=70;
    class Inner
    {
     private int index=60;
     void print()
     {
      int index=80;
      System.out.println(index);  //访问print()方法中的index=80变量
      System.out.println(this.index); //访问Inner类的成员变量index=60;
      System.out.println(Middle.this.index); //访问Middle类的成员变量index=70;
      System.out.println(Outer.this.index);  //访问Outer类的成员变量index=100;
      System.out.println(a);
      System.out.println(b);
     }
    }
   }
  }
 }
/*
 *我们可以把内部类放到一个方法中，但是它的使用范围也定在了这个方法的范围里，甚至可以放到if()块
 *代码块中{}中，它告诉我们，不管我们把Inner()嵌套有多深，它都可以随意的访问外部类中的所有成员
  void fn()
  {
  class Inner          
  {                   
  private int index=50;
  void print()
  {
   int index=30;
   System.out.println(index);
   System.out.println(this.index);
   System.out.println(Outer.this.index);
  }
  }   
  }
  */
  static class Inner      
 {                  
  private int index=50;
  void print()
  {
    int index=80;
    System.out.println(index);  //访问print()方法中的index=80变量
    System.out.println(this.index); //访问Inner类的成员变量index=60;
    System.out.println(Outer.this.index);  //访问Outer类的成员变量index=100;
  }
 }
 
 void print()
 {
  //Inner inner=new Inner();
  //inner.print();
 }
 /*
 Inner getInner()
 {
  return new Inner();
 }
 */
 /*
 public static void main(String[] args)
 {
  Outer outer=new Outer();
  //outer.print();
  //Inner in=outer.getInner();这是一句错误的代码，因为Inner是定义在Outer类的内部的，所以对外是
  //不可见的，这个时候需要我们，使用外部类名来调用
  Inner in=outer.getInner(); //因为现在main()方法在Outer类里，这个时候Inner类对于main()方法来说是可见的
  Inner in=new Inner();
  in.print();
 }*/
}
class Test
{
 /*public static void main(String[] args)
 {
  Outer outer=new Outer();
  //outer.print();
  //Inner in=outer.getInner();这是一句错误的代码，因为Inner是定义在Outer类的内部的，所以对外是
  //不可见的，这个时候需要我们，使用外部类名来调用
  Outer.Inner in=outer.getInner();
  in.print();
 }*/
 public static void main(String[] args)
 {
  Outer outer=new Outer();
  //outer.print();
  //Inner in=outer.getInner();这是一句错误的代码，因为Inner是定义在Outer类的内部的，所以对外是
  //不可见的，这个时候需要我们，使用外部类名来调用
  //Outer.Inner in=outer.getInner();
  Outer.Inner in=outer.new Inner();  //用外部类对象来产生
  in.print();
 }
}
*****************************************************************************

从内部类派生的用法:
/*
 *从内部类派生的用法
*/
class Car
{
 class Wheel
 {
 }
}
class PlaneWheel extends Car.Wheel
{
 PlaneWheel(Car car)
 {
  car.super();  //建立内部类对象到子类的引用
 }
 public static void main(String[] args)
 {
  Car car=new Car();
  PlaneWheel pw=new PlaneWheel(car);
 }
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

内部类实现接口:
//用内部类实现接口,接口不能被实例化
interface Animal
{
 void eat();
 void sleep();
}
class Zoo
{
 private class Tiger implements Animal
 {
  public void eat()
  {
   System.out.println("Tiger eat!");
  }
  public void sleep()
  {
   System.out.println("Tiger sleep!");
  }
 }
 
 Animal getAnimal()
 {
  return new Tiger();
 }
 /*
 Animal getAnimal()
 {
  return new Animal()
  {                       //这是就是匿名的类
   public void eat()
   {
    System.out.println("Animal eat!");
   }
   public void sleep()
   {
    System.out.println("Animal sleep!");
   }
  };                   //这是就是匿名的类
 }*/
}
class DoTest
{
 public static void main(String[] args)
 {
  Zoo z=new Zoo();
  Animal an=z.getAnimal();
  an.eat();
  an.sleep();
 }
}
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

基类中有个方法和接口中的方法,同名，但是他们的用法不一样:
//基类中有个方法和接口中的方法,同名，但是他们的用法不一样
interface Machine
{
 void run();
}

class Person
{
 public void run()
 {
  System.out.println("run");
 }
}

class Robot extends Person
{
 private class MachineHeart implements Machine
 {
  public void run()
  {
   System.out.println("heart run");
  }
 }
 Machine getMachine()
 {
  return new MachineHeart();
 }
}

class Work
{
 public static void main(String[] args)
 {
   Robot robot=new Robot();
   Machine m=robot.getMachine();
   m.run();
   robot.run();  
 }
}

/*
class Feeder implements Cloneable
{
 String name;
 int age;
 public Feeder(String name,int age)
 {
  this.name=name;
  this.age=age;
 }
 public Object clone()
 {
  Object o=null;
  try
  {
   o=super.clone();
  }
  catch(CloneNotSupportedException e)
  {
   System.out.println(e.toString());
  }
  return o;
 }
}
*/

class Feeder
{
 String name;
 int age;
 public Feeder(String name,int age)
 {
  this.name=name;
  this.age=age;
 }
}

class Animal implements Cloneable
{
 String name;
 int weight;
 Feeder f;
 public Animal(String name,int weight,Feeder f)
 {
  this.name=name;
  this.weight=weight;
  this.f=f;
 }
 public String toString()
 {
  return "name="+name+","+"weight="+weight;
 }
 public Object clone()
 {
  Object o=null;
  //Animal o=null;
  try
  {
   o=super.clone();
  }
  catch(CloneNotSupportedException e)
  {
   System.out.println(e.toString());
  }
  //o.f=(Feeder)f.clone();
  return o;
 }
}
我们看输出结果:
F:\Java Develop>javac TestClone.java
F:\Java Develop>java TestClone
baidu
60
从结果可以看出来我们修改了an2.f.name和an.f.age但是an1去发生了变化,这是因为我们没有对Feeder类进行克隆,这就是浅克隆,为了解决这个问题我们需要用到Deeply克隆,java默认的克隆方式是浅克隆.
代码如下:
class TestClone
{
 public static void main(String[] args)
 {
  Feeder f=new Feeder("google",50);
  Animal an1=new Animal("Dog",50,f);
  Animal an2=(Animal)an1.clone();
  an2.f.name="baidu";
  an2.f.age=60;
  System.out.println(an1.f.name);
  System.out.println(an1.f.age);
 }
}

class Feeder implements Cloneable
{
 String name;
 int age;
 public Feeder(String name,int age)
 {
  this.name=name;
  this.age=age;
 }
 public Object clone()
 {
  Object o=null;
  try
  {
   o=super.clone();
  }
  catch(CloneNotSupportedException e)
  {
   System.out.println(e.toString());
  }
  return o;
 }
}

class Animal implements Cloneable
{
 String name;
 int weight;
 Feeder f;
 public Animal(String name,int weight,Feeder f)
 {
  this.name=name;
  this.weight=weight;
  this.f=f;
 }
 public String toString()
 {
  return "name="+name+","+"weight="+weight;
 }
 public Object clone()
 {
  //Object o=null;
  Animal o=null;
  try
  {
   o=(Animal)super.clone();
  }
  catch(CloneNotSupportedException e)
  {
   System.out.println(e.toString());
  }
  o.f=(Feeder)f.clone();
  return o;
 }
}
输出结果如下:
F:\Java Develop>javac TestClone.java
F:\Java Develop>java TestClone
google
50
java浅克隆是指copy类里所有没有引用类型的变量.Deeply Clone则刚好相反.

public class TestRegex
{
 public boolean isEmail(String email)
 {
             //指定使用的模式
  Pattern pattern=Pattern.compile
            ("\\p{Digit}+@\\w+\\.\\p{Alpha}{2,3}");
  String[] words=pattern.split(email);
  Matcher matcher=pattern.matcher(email);
  if(matcher.find()&&words.length==0)
    return true;
  else
    return false;
 }
}
来看怎么用它:
Code:
public class Client
{
 public static void main(String[] args)
 {
  TestRegex regex=new TestRegex();
  String s1="DuYang163@gmail.com";
  String s2="feiyang@126.123.com";
  System.out.println(s1+(regex.isEmail(s1)?"是":"不是")+"Email格式!");
  System.out.println(s2+(regex.isEmail(s2)?"是":"不是")+"Email格式!");
 }
}
一些常用的表达式格式:
文字(Literal): 表达式内任何不具有特殊意义的字符都被看做是一个文字，并与自身匹配。
量词(Quantifier): 某些字符或者表达式，他们被用来计算一个文字或分组可以字符列中出现的次数，以便该序列与表达式匹配。
例：
? 表示出现一次或根本不出现。
* 表示出现零次或一次以上(含一次)。
+ 表示出现一次或多次。
字符类(Character class): 一个字符类就是方括号内的一个字符集，其中，匹配可以是括号内的任意一个字符。可以把字符和量词结合起来，例如，[acegikmoqsuwy*]
                        将是只包含字母表中奇数字母的任意字符列。某些字符列是预先定义好的:
\d-数字(0到9)
\D－非数字
\s-空白字符，如制表符或换行符
\S-非空白字符
\w-单字符(a到z,A到Z,0到9以及下划线)
\W-非单字字符(其他任意字符)
Posix 字符类(Posix character class): 某些字符仅在用于US-ASCII比较时才有效。
例如：
\p{Lower}-小写字符
\p{Upper}-大写字符
\p{ASCII}-所有ASCII字符
\p{Alpha}-字符字符(\p{Lower}与\p{Upper}相结合)
\p{Digit}-从0到9的数字
\p{Alnum}-字母数字字符
范围(Range): 使用短线(dash)来指定范围。例如：[A-J]表示从A到J的大写字母。
否定(Negation): 使用脱字符^表示否定字符。例如：[^A-K]表示除A到K之外的任何字符。