《Thinking in Java》Five

最新推荐文章于 2025-09-08 22:39:06 发布

转载最新推荐文章于 2025-09-08 22:39:06 发布 · 65 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：https://my.oschina.net/doudoulee/blog/651973

文章标签：

#java #python

2019独角兽企业重金招聘Python工程师标准>>>

方法重载：方法名相同，形式参数不同。

默认构造器（无参构造器）：名字与类名相同的方法。作用是创建一个“默认对象”。若类中没有构造器，编译器会自动帮你创建一个默认构造器，如果已经定义了构造器（无论是否有参），编译器就不会再自动创建默认构造器。

 package Fifth;

class Happy{

//默认构造器

 Happy(){
  System.out.println("I want to be happier");
 }
 Happy(String s){
  System.out.println(s);
 }
}
public class DefaultConstructor {
 public static void main(String[] args){
 new Happy();
 new Happy("I am happy");
}
}

this关键字：this关键字只能在方法内部使用，表示调用方法的对象的引用。

package Fifth;

class Apple{
 public void eat(){
  Apple a = new Apple();
  a.taste(a);

  a.taste(this);//将自身传递给外部方法taste(). this表示对当前对象的引用

 }
 public void taste(Apple apple){
  System.out.println("Good");
  
 }
}
public class NoConstructor {
 public static void main(String[] args){
  Apple a1 = new Apple();
  a1.eat();
 }
}

static关键字：在static方法内部不能调用非static方法（不是完全不可能，传递一个对象的引用到static方法里，通过这个引用就可以调用static和非static的方法和成员了），但反过来可以在没有创建任何对象的前提下仅仅通过类本身来调用静态方法。

静态块：Java允许多个静态初始化组织成一个用"｛｝"括起来的静态块。

package Fifth;
class StringS{
 static String str = new String("ABC");
 static String str1;
 
 //静态块
 
 static{
  str1 = new String("DEF");
  System.out.println(str1);
 }
 static void prt(){
  System.out.println(str+str1);
 }
}
public class StaticString {
 public static void main(String[] args){
  System.out.println("main");
  //System.out.println(StringS.str);
  //System.out.println(StringS.str1);
  
  StringS.prt();//用类名直接调用static方法
  
 }
 static StringS ss = new StringS();
 
 //初始化的顺序是先静态对象再非静态对象

}/*
DEF
main
ABCDEF*/

初始化顺序：静态初始化只执行一次，先静态后非静态。

package Fifth;
class Cup{  
    Cup(int marker){  
        System.out.println("Cup()" + marker);  
    }  
    void f(int marker){  
        System.out.println("f("+marker+")");  
    }  
}  //
class Cups{  
    static Cup cup1;  
    static Cup cup2;  
    static {  
        cup1 = new Cup(1);  
        cup2 = new Cup(2);  
    }  
    Cups(){  
        System.out.println("Cups()");  
    }  
} // 
public class Main {  
    public static void main (String args[]){  
        System.out.println("main()");  
        //Cup  cup1 = new Cup(1);  
        Cups.cup1.f(99);  
    }  
  
    static Cups cups1 = new Cups();//Cups()的静态初始化动作。Cup()1、Cup()2在new Cups()的时候被创建一次
  
    static Cups cups2 = new Cups();  //在第二次new Cups()时不会再被创建


}                                    //对比之下，方法Cups()被执行了两次

/*Output:在执行main()之前静态域先被初始化，最后执行非静态方法f()
Cup()1
Cup()2
Cups()
Cups()
main()
f(99)*/

垃圾回收：finaliza()

垃圾回收器只知道释放经由new分配的内存，不知道如何释放不使用new获得的内存区，因此Java允许在类中定义一个finaliza()方法回收程序不再使用的内存。

 package Fifth;
public class FinalizeD {
 
 @Override
 protected void finalize(){
  System.out.println("finalize excute");
 }
 public static void main(String[] args){
  FinalizeD f = new FinalizeD ();

  /*finalize()被调用的条件, (1)类未被调用(置null), (2)调用System.gc(). */

  f = null;
  System.gc();
 }
}/*Output:
finalize excute*/

可变参数列表：不用指定具体的参数，编译器会根据所定义的去适应，可应用于参数个数或类型未知的情况。

package Fifth;
public class KeBianCanLie{

 //可变参数列表

 static void f(int required,String...trailing){
  System.out.print("required: "+required+"");
  for(String s:trailing)
   System.out.print(s+" ");
  System.out.println();
 }
 
 public static void main(String[] args){
 
 // f(int required,String...trailing)第二个参数是可变参数列表，可以传入任意数量的参数个数
 
  f(1,"one");

  f(2,"two","three");
  f(0);
 }
}/*required: 1one 
required: 2two three 
required: 0
*/

枚举类型enum(): enum是一个类

//enumD.java
package Fifth;
public enum enumD{
 NOT,MILD,MEDIUM,HOT,FLAMING
}

package Fifth;
public class EnumDD {

 enumD degree; //当成一个类来使用

 public EnumDD(enumD degree){
  this.degree = degree;
 }
 public void describe(){
  switch(degree){
  case NOT:
  case MILD:
  case HOT:
  case FLAMING:
  default:
   System.out.println("enum");
  }
 }
 public static void main(String[] args){
  EnumDD enu = new EnumDD(enumD.NOT);
  enu.describe();
 }
}
/*NOT
enum*/

转载于:https://my.oschina.net/doudoulee/blog/651973