国产成一区二区,国产精选一区,户外极限露出调教在线视频

Outer Class & Inner Class

Dalston.Young — Thu, 01 Jun 2006 03:24:00 GMT

Inner Class

a> 在一个类中定义一个类�Q�这个类��叫做内部类或者内�|�类(inner class).
b> 内部�c�d��以让我们��逻辑上相关的一�l�类�l�织��h��Q��ƈ由外部类(outer class)
   来控制内部类的可见�?
c> 当我们徏立一个inner class的时�?其对象就拥有了与外部�c�d��象之间的一�U�关�p?
   �q�是通过一个特�D�的this inference形成的，使得内部�c�d��象可以随意的讉K��外部
   �c�M��的所有成员�?br />d> 在内部类中可以访问外部类的私有成员变量，也就是在内部�c�M��可以随意的访�?br />   外部�c�M��的所有的成员�Ҏ��和变�?br />e> 可以把内部类攑ֈ�一个方法中来定义，但是它的使用范围必须是在�q�个�Ҏ��?br />f> 当我们在一个方法中定义一个内部类�Ӟ��如果我们需要在�Ҏ��中内部类去访问这�?br />   本地变量�Q�方法中声明的变量）�Ӟ��我们必须把这个变量声明�ؓfinal才行�Q�不�?br />   �~�译器会报错
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); //讉K��print()�Ҏ��中的index=80变量
      System.out.println(this.index); //讉K��Inner�cȝ��成员变量index=60;
      System.out.println(Middle.this.index); //讉K��Middle�cȝ��成员变量index=70;
      System.out.println(Outer.this.index); //讉K��Outer�cȝ��成员变量index=100;
     }
    }
   }
  }
}
f> 对于Inner�cȝ��讉K��权限我们可以声明为所有的(protected,private,public,default)�?br />h> 对于内部�c�L��_��如果赯��问权限�ؓprotected�Q�那么他可以在同一个类被访也可以在�?br />   一个包中被讉K��。而如果声明�ؓprivate的那么那只能在Outer�q�个外部�c�被讉K��。我�?br />   可以把它生命为abstract(�q�个时候不能用Inner直接��d��例化一个内部类)�Q�我们可以在
   外部�c�M��定义一个类�Q�从Inner�z��出来�Q�直接实例化。当我们声明为final�Q�那��׃��能再
   �z��了，对于内部�c�L��说还可以声明为static�Q�那么这个时候就可以不需要同时存在外�?br />   �cȝ��对象�Q�那么这个时候我们也不能讉K��外部�cȝ��非静态的成员变量和方法。相当于切断
   了与外部内对象的联系。非静态的内部�c�M��能在内部�c�L��w�中定义静态的�Ҏ��(反之可以)�?br />   非static的内部类中的成员变量不能声明为static的，只在��层�c�L��static的内部类中可�?br />   声明为static的�?br />g> ��Z��么要使用内部�c�？
   1.在内部类(inner class)中可以随意访问外部类中的成员�Q�让我们更好的管理和�l�织我们
   的代码。增��Z��码的可读性�?br />   2.内部�cȝ��于创建适配器类,适配器类是用于实现接口的�c�，使用内部�c�L��实现接口�Q�可�?br />   更好的定位与接口兌��的方法在代码中的位置�?br />   3.其他的用�?br />   a> 我们可以通过把内部类声明为private来隐藏接口的实现�l�节
   b> 我们需要派生一个类�Q�同时又需要去实现一个接口，如果基类中有个方法和接口中的�Ҏ��
   同名�Q�但是他们的用法不一��P��我们��可以用内部�c�L��解决�?br />=============================================================================

内部�cȝ��一般用�?
class Outer            //Outer class
{
private int index=100; //�U�有的变�?br /> /*
class Inner           //Inner Class,independence individual
{                     //可以整体的把Inner�cȝ��成是Outer�cȝ��一个成�?br />  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�c�M��嵌套层�ơ有多深�Q�都可以随意的访问外部的成员变量
*当我们在一个方法中定义一个内部类�Ӟ��如果我们需要在�Ҏ��中内部类去访问这�?br /> *本地变量�Q�方法中声明的变量）�Ӟ��我们必须把这个变量声明�ؓfinal才行�Q�不�?br /> *�~�译器会报错
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); //讉K��print()�Ҏ��中的index=80变量
      System.out.println(this.index); //讉K��Inner�cȝ��成员变量index=60;
      System.out.println(Middle.this.index); //讉K��Middle�cȝ��成员变量index=70;
      System.out.println(Outer.this.index); //讉K��Outer�cȝ��成员变量index=100;
      System.out.println(a);
      System.out.println(b);
     }
    }
   }
  }
}
/*
*我们可以把内部类攑ֈ�一个方法中�Q�但是它的��用范围也定在了这个方法的范围里，甚至可以攑ֈ�if()�?br /> *代码块中{}中，它告诉我们，不管我们把Inner()嵌套有多深，它都可以随意的访问外部类中的所有成�?br /> 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); //讉K��print()�Ҏ��中的index=80变量
    System.out.println(this.index); //讉K��Inner�cȝ��成员变量index=60;
    System.out.println(Outer.this.index); //讉K��Outer�cȝ��成员变量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();�q�是一句错误的代码�Q�因为Inner是定义在Outer�cȝ��内部的，所以对外是
  //不可见的�Q�这个时候需要我们，使用外部�c�d��来调�?br />  Inner in=outer.getInner(); //因�ؓ现在main()�Ҏ��在Outer�c�里�Q�这个时候Inner�c�d��于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();�q�是一句错误的代码�Q�因为Inner是定义在Outer�cȝ��内部的，所以对外是
  //不可见的�Q�这个时候需要我们，使用外部�c�d��来调�?br />  Outer.Inner in=outer.getInner();
  in.print();
}*/
public static void main(String[] args)
{
  Outer outer=new Outer();
  //outer.print();
  //Inner in=outer.getInner();�q�是一句错误的代码�Q�因为Inner是定义在Outer�cȝ��内部的，所以对外是
  //不可见的�Q�这个时候需要我们，使用外部�c�d��来调�?br />  //Outer.Inner in=outer.getInner();
  Outer.Inner in=outer.new Inner(); //用外部类对象来��?br />  in.print();
}
}
*****************************************************************************

从内部类�z��的用�?
/*
*从内部类�z��的用�?br />*/
class Car
{
class Wheel
{
}
}
class PlaneWheel extends Car.Wheel
{
PlaneWheel(Car car)
{
  car.super(); //建立内部�c�d��象到子类的引�?br /> }
public static void main(String[] args)
{
  Car car=new Car();
  PlaneWheel pw=new PlaneWheel(car);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

内部�c�d��现接�?
//用内部类实现接口,接口不能被实例化
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()
  {                       //�q�是��是匿名的类
   public void eat()
   {
    System.out.println("Animal eat!");
   }
   public void sleep()
   {
    System.out.println("Animal sleep!");
   }
  };                   //�q�是��是匿名的类
}*/
}
class DoTest
{
public static void main(String[] args)
{
  Zoo z=new Zoo();
  Animal an=z.getAnimal();
  an.eat();
  an.sleep();
}
}
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

基类中有个方法和接口中的�Ҏ��,同名�Q�但是他们的用法不一�?
//基类中有个方法和接口中的�Ҏ��,同名�Q�但是他们的用法不一�?br />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();
}
}

Dalston.Young 2006-06-01 11:24 发表评论

��谈Java的Clone

Dalston.Young — Sun, 07 May 2006 13:52:00 GMT

    我们知道在Java在java中，传参�Ӟ��都是以传值的形式�q�行。对于基本数据类型，传递的是数据的拯��Q�对于引用类型，传递的引用的拷贝。�ؓ了获取对象的一份拷贝，我们可以利用Object�cȝ��clone()�Ҏ��。至于怎么��h��实现Clone我们必须做以下的事情:
1> 在派生类中覆盖基�cȝ��clone()�Q��ƈ声明为public�?br />2> 在派生类的clone()�Ҏ��中，调用super.clone()�?br />3> 在派生类中实现Cloneable接口�?br />4> 没有抽象�Ҏ��的接口叫标识接口�?br />5> ��Z��么我们在�z��c�M��覆盖Object的clone()�Ҏ��Ӟ��一定要调用super.clone()�?在运行时�?Object
   的clone()�Ҏ��能识别出你要复制的是哪一个对象，然后为此对象分配�I�间�Q��ƈ�q�行对象的复�Ӟ��原
   始对象的内容一一复制到新的对象空间去�?br />我们看下面的例子:

class TestClone
{
public static void main(String[] args)
{
      Animal an1=new Animal("Dog",50);
     Animal an2=(Animal)an1.clone();
      an2.name="Fox";
      an2.weight=30;
     System.out.println(an1);
   }
}
class Animal implements Cloneable
{
   String name;
   int weight;
public Animal(String name,int weight)
   {
       this.name=name;
     this.weight=weight;
   }
public String toString()
{
      return "name="+name+","+"weight="+weight;
}
public Object clone()
  {
     Object o=null;
  try
   {
      o=super.clone();
    }
  catch(CloneNotSupportedException e)
  {
       System.out.println(e.toString());
  }
     return o;
}
}
�q�行�l�果如下:
F:\Java Develop>javac TestClone.java
F:\Java Develop>java TestClone
name=Dog,weight=50
我们看到我们修改an2的值�ƈ没有影响到an1里的�?�q�就是克隆的作用.是因为在�q�里通过Clone我们在内存中�?块地方用来储存不同的an1,an2
我们在看下面一个例�?我们再增加一个动物的饲养员类,来相兛_��具体的每个动�?
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 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��d��生了变化,�q�是因�ؓ我们没有对Feeder�c�进行克�?�q�就是浅克隆,��Z��解决�q�个问题我们需要用到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;
}
}

Dalston.Young 2006-05-07 21:52 发表评论

Dalston.Young — Fri, 05 May 2006 00:04:00 GMT

在新的JDK中加入了对��用正则表辑ּ�的模式匹配的支持。正则表辑ּ�是根据文本匹配模式的�Ҏ��Q�类��g��~�译器生成类文�g的工作原理�?br />在正则表辑ּ�的上下文中，模式是序列的文本表示�Ҏ��。例如，我们想知道一个字�W�序列中是否存在"money"�q�个词，��可以��用模式money,
因�ؓ�q�是�_��表示该字�W�串的方法�?br /> 我们�q�样来检验用戯��入的是否��Z��合法的email地址:
Code:
import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class TestRegex
{
public boolean isEmail(String email)
{
             //指定使用的模�?br />  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): 表达式内��M��不具有特�D�意义的字符都被看做是一个文字，�q�与自��n匚w��?br />量词(Quantifier): 某些字符或者表辑ּ��Q�他们被用来计算一个文字或分组可以字符列中出现的次敎ͼ�以便该序列与表达式匹配�?br />例：
? 表示出现一�ơ或�Ҏ��不出现�?br />* 表示出现零次或一�ơ以�?含一��?�?br />+ 表示出现一�ơ或多次�?br />字符�c?Character class): 一个字�W�类��是�Ҏ��号内的一个字�W�集�Q�其中，匚w��可以是括号内的�Q意一个字�W�。可以把字符和量词结合�v来，例如�Q�[acegikmoqsuwy*]
                        ��是只包含字母表中奇数字母的��L��字符列。某些字�W�列是预先定义好�?
\d-数字(0�?)
\D�Q�非数字
\s-�I�白字符�Q�如制表�W�或换行�W?br />\S-非空白字�W?br />\w-单字�W?a到z,A到Z,0�?以及下划�U?
\W-非单字字�W?其他��L��字符)
Posix 字符�c?Posix character class): 某些字符仅在用于US-ASCII比较时才有效�?br />例如�Q?br />\p{Lower}-��写字符
\p{Upper}-大写字符
\p{ASCII}-所有ASCII字符
\p{Alpha}-字符字符(\p{Lower}与\p{Upper}相结�?
\p{Digit}-�?�?的数�?br />\p{Alnum}-字母数字字符
范围(Range): 使用短线(dash)来指定范围。例如：[A-J]表示从A到J的大写字母�?br />否定(Negation): 使用脱字�W�^表示否定字符。例如：[^A-K]表示除A到K之外的�Q何字�W��?/p>

Dalston.Young 2006-05-05 08:04 发表评论

国产成一区二区,国产精选一区,户外极限露出调教在线视频

Outer Class & Inner Class

���谈Java的Clone

��谈Java的Clone