码迷,mamicode.com
首页 > 编程语言 > 详细

重拾java系列一java基础(4)

时间:2015-09-14 13:45:15      阅读:239      评论:0      收藏:0      [点我收藏+]

标签:

  本章主要回顾一些类的相关知识:

(1)static:

  static 静态的: 属于类的资源, 使用类名访问.
  静态属性: 只有一份的变量
  静态方法: 是属于类方法, 可以使用类名直接访问. 静态方法中没有this引用
  静态代码块: 是在类加载期间执行的代码块

  延伸:代码块,在对象创建期间执行, 类似于构造器中的代码

  参考例子:

 

 1 /**
 2  * 代码块: 在对象创建期间执行, 类似于构造器中的代码 
 3  * 静态代码块: 在类加载期间执行. 静态代码可以用于只加载一次的静态资源, 如: 图片的加载
 4  */
 5 public class Demo01 {
 6     public static void main(String[] args) {
 7         Foo f1 = new Foo();
 8         Foo f2 = new Foo();
 9     }
10 }
11 
12 class Foo {
13     //静态代码块
14     static {
15         System.out.println("加载 Foo.class");
16     }
17     {
18         System.out.println("HI");
19     }// 代码块, 很少使用!
20 }

运行结果:加载 Foo.class
              HI
              HI

是有顺序的,请注意看上面的注释

(2)匿名内部类:匿名内部类也就是没有名字的内部类

正因为没有名字,所以匿名内部类只能使用一次,它通常用来简化代码编写

但使用匿名内部类还有个前提条件:必须继承一个父类或实现一个接口

实例1:不使用匿名内部类来实现抽象方法

 1 abstract class Person { 
 2     public abstract void eat(); 
 3 } 
 4   
 5 class Child extends Person { 
 6     public void eat() { 
 7         System.out.println("eat something"); 
 8     } 
 9 } 
10   
11 public class Demo { 
12     public static void main(String[] args) { 
13         Person p = new Child(); 
14         p.eat(); 
15     } 
16 } 

 

运行结果:eat something

可以看到,我们用Child继承了Person类,然后实现了Child的一个实例,将其向上转型为Person类的引用

但是,如果此处的Child类只使用一次,那么将其编写为独立的一个类岂不是很麻烦?

这个时候就引入了匿名内部类

 

实例2:匿名内部类的基本实现

 1 abstract class Person { 
 2     public abstract void eat(); 
 3 } 
 4   
 5 class Child extends Person { 
 6     public void eat() { 
 7         System.out.println("eat something"); 
 8     } 
 9 } 
10   
11 public class Demo { 
12     public static void main(String[] args) { 
13         Person p = new Child(); 
14         p.eat(); 
15     } 
16 } 

 

运行结果:eat something

可以看到,我们直接将抽象类Person中的方法在大括号中实现了

这样便可以省略一个类的书写

并且,匿名内部类还能用于接口上

 

实例3:在接口上使用匿名内部类

 1 interface Person { 
 2     public void eat(); 
 3 } 
 4   
 5 public class Demo { 
 6     public static void main(String[] args) { 
 7         Person p = new Person() { 
 8             public void eat() { 
 9                 System.out.println("eat something"); 
10             } 
11         }; 
12         p.eat(); 
13     } 
14 } 

 

运行结果:eat something

 

由上面的例子可以看出,只要一个类是(抽象非抽象均可)或是一个接口,那么其子类中的方法都可以使用匿名内部类来实现

最常用的情况就是在多线程的实现上,因为要实现多线程必须继承Thread类或是继承Runnable接口

 

实例4:Thread类的匿名内部类实现

 1 public class Demo { 
 2     public static void main(String[] args) { 
 3         Thread t = new Thread() { 
 4             public void run() { 
 5                 for (int i = 1; i <= 5; i++) { 
 6                     System.out.print(i + " "); 
 7                 } 
 8             } 
 9         }; 
10         t.start(); 
11     } 
12 } 

 

运行结果:1 2 3 4 5

 

实例5:Runnable接口的匿名内部类实现

 1 public class Demo { 
 2     public static void main(String[] args) { 
 3         Runnable r = new Runnable() { 
 4             public void run() { 
 5                 for (int i = 1; i <= 5; i++) { 
 6                     System.out.print(i + " "); 
 7                 } 
 8             } 
 9         }; 
10         Thread t = new Thread(r); 
11         t.start(); 
12     } 
13 } 

 

运行结果:1 2 3 4 5

以上例子摘自http://www.cnblogs.com/nerxious/archive/2013/01/25/2876489.html,有一个人懒得整理,见谅,不过楼主整理的真心不错

 

重拾java系列一java基础(4)

标签:

原文地址:http://www.cnblogs.com/iliuyuet/p/4806531.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!