java面向對象九個經典例子程序

1 Hello world例子

package Example;      //定義自己的包名  
   
public class Example1                    //定義一個類  
{  
    public static void main(String[] args)          //系統可以執行的main方法,這里是一個公有靜態無返回值的方法  
    {  
        System.out.println("Hello world!");  
//調用java.lang包中的System類的PrintLine方法輸出Hello world!  
    }  
}  

2 類的基本組成示例

package Example;  
class Person  
    {  
        public int age;             //聲明公共字段age  
       private String name;        //聲明私有字段name,此時name為類的屬性,下面通過公有方法進行訪問  
       public String getName() {  
           return name;  
       }  
       public void setName(String name) {  
           this.name = name;  
       }  
        
       public void eat()           //定義無參數的eat方法  
       {  
          System.out.println("Person can eat");  
       }  
       public void eat(String s)   //定義帶參數的eat方法,實現方法重載  
       {  
          System.out.println("Person can eat"+s);  
       }  
       public Person()            //定義無參構造函數,注意無返回值定義,方法與類同名  
       {  
       }  
       public Person(int age, String name) //重寫一個帶參數構造函數,注意無返回值定義,方法與類同名  
       {  
           this.age = age;         //前一個age為對象的字段,由this指定,后一個age為函數形參  
           this.name = name;       //前一個name為對象的屬性,由this指定,因為在本類中可直接訪問,后一個name為函數形參  
           }  
        
}  
public class Example2  
{  
    public static void main(String[] args)  
    {  
        Person person1 = new Person();  //調用類的無參構造函數  
    person1.age = 20;               //給對象的公有字段直接賦值  
    person1.setName("zhangsan");      //必須使用公共方法才能給對象的屬性賦值  
    System.out.println("第一個人信息,姓名:"+person1.getName()+"年齡:"+person1.age);  
    person1.eat();                  //調用對象的無參方法  
    Person person2 = new Person(18, "lisi");//調用類的有參構造函數  
    System.out.println("第二個人信息,姓名:" + person2.getName() + "年齡:" + person2.age);  
    person2.eat(" 饅頭");           //調用對象的有參方法  
   
    }  
}  

3靜態與非靜態變量及方法的使用

package Example;  
   
class Example3  
{  
    public int x;          //非靜態變量  
    public static int y;     //靜態變量  
    void method()       //非靜態方法  
    {  
        x = 1;   //正確,非靜態方法可以訪問非靜態成員  
        y = 1;   //正確，非靜態方法可以訪問靜態成員  
       System.out.println("實例方法訪問：x="+x+" y="+y);  
    }  
    static void smethod()     //靜態方法  
    {  
        //x = 3;  錯誤，靜態方法不能非靜態成員  
        y = 3;   //正確，靜態方法可以訪問靜態成員  
       System.out.println("靜態方法訪問：y="+y);  
    }  
    public static void main(String[] args)  
    {  
    Example3 prog3 = new Example3();//生成類的實例  
        prog3.method();    //非靜態方法通過實例來調用  
   
        Example3.smethod();  //靜態方法通過類名來調用  
    }  
}  

4 類繼承的例子

package Example;  
    
class mother  
{  
    public static String sex;//成員變量  
    public void method1()//父類成員方法1  
    {  
       System.out.println("母親的方法1!");  
    }  
    public  void method2() //父類成員方法2  
    {  
       System.out.println("母親的方法2!");  
    }  
}  
class boy extends mother //繼承  
{  
    public  void method2() //改寫父類成員方法,Java中方法均為虛方法  
    {  
       System.out.println("我自己的方法2!");  
    }  
}  
public class Example4  
{  
    public static void main(String[] args)  
    {  
        boy boys = new boy();  
        boy.sex = "男孩";//靜態變量的繼承  
       System.out.println("繼承而來的字段sex的值為："+boy.sex);  
        boys.method1();//來自父類的方法  
        boys.method2();//自己改寫后的方法  
    }  

5類的訪問修飾符

package Example;  
   
class program1  
{  
    public int a;      //公用成員  
    protected int b; //保護成員  
    int c;     //友好成員  
    private int d;      //私有成員  
    public void method1()  
    {  
        a = 1;  //內部訪問公用成員，正確  
        b = 1;  //內部訪問保護成員，正確  
        c = 1;  //內部訪問友好成員，正確  
        d = 1;  //內部訪問私有成員，正確  
       System.out.println("a="+a+",b="+b+",c="+c+",d="+d);  
    }  
}  
class program2  
{  
    public void method2()  
    {  
        program1 prog1 = new program1();  
        prog1.a = 2;  
        //prog1.b=2  //錯誤，只能在類的內部訪問或在它的繼承類里訪問  
        prog1.c=2;    // 正確，在同一個程序集里都可以訪問  
        //prog1.d = 2; //錯誤，只能在它的類的內部訪問  
       System.out.println("另一個類中訪問公有成員a="+prog1.a+",友好成員c="+prog1.c);  
    }  
}  
class program3 extends program1  
{  
    public void method3()  
    {  
         
        b = 4;   //正確，保護成員可以在它的繼承類里訪問  
       System.out.println("子類可以訪問受保護成員b="+b);  
    }  
}  
public class Example5  
{  
    public static void main(String[] args)  
    {  
        program1 prog1 = new program1();  
        prog1.method1();  
        program2 prog2 = new program2();  
        prog2.method2();  
        program3 prog3 = new program3();  
        prog3.method3();  
    }  
}    

6抽象類及其實現示例

package Example;  
   
//應該注意的是：繼承抽象類的類，要求抽象類中的抽象方法要被實例化  
abstract class personClass //抽象類  
{    
    public String sex;//變量。  
    public abstract void method(); //抽象方法。  
}  
class man extends personClass //以抽象類為模塊的類  
{    
    public  void method()//抽象方法的實例化  
    {  
       System.out.println("繼承抽象類的方法被實現化了");  
    }  
}  
public  class Example6  
{  
    public static void main(String[] args)  
    {  
        man boys = new man();//產生一個對象  
        boys.sex = "male";//給對象一個初值  
        System.out.println(boys.sex);  
        boys.method();//調用man類中的方法  
    }  
}  

7接口及其實現

package Example;  
   
interface Iinterface //定義一個接口  
{  
    int i=10;      //定義的變量為fianal類型；  
    void method();  // 聲明接口方法，但不能有方法體{}  
}  
public class Example7 implements Iinterface    //實現接口  
{  
    public void method()   //接口的方法在此必須被重寫，注意訪問修飾符為public  
    {  
       System.out.println("接口實現成功！！！");  
    }  
    public static void main(String[] args)  
    {  
    Example7 prog7 = new Example7();  
    //prog7.i=10;      不能修改ｉ的值，為final類型  
        prog7.method();   
    }  
}  

8 抽象類與接口混合編程例子

package Example;  
   
    interface myInterface  //定義一個接口  
    {  
        void method1();  
   
    }  
    abstract class abstractClass//定義一個抽象類  
    {  
   
         public abstract void method2(); //加abstract  
    }  
    class shixianlei extends abstractClass implements myInterface //繼承抽象類，實現接口。  
    {  
        public String st;       //定義自己的字段  
        public void method1()   //實現接口，注意訪問修飾符加public  
        {  
           System.out.println("接口方法已加public實現");  
        }  
   
        public void method2()//實現抽象方法  
        {  
           System.out.println("抽象類方法已實現");  
        }  
   
    }  
    public class Example8  
    {  
        public static void main(String[] args)  
        {  
            shixianlei sxl = new shixianlei();  
            sxl.st = "實現類的字段";  
            System.out.println(sxl.st);  
            sxl.method1();//實現的接口方法調用  
            sxl.method2();//實現的抽象類的方法調用  
   
        }  
    }  

9 接口回調與多態性

package Example;  
   
    interface Eat  //定義一個接口  
    {  
        void eat();  
   
    }  
   
     
    class Cow implements Eat //實現接口。  
    {  
        public String name="牛哞哞";       //定義自己的字段  
        public void eat()   //實現接口，注意訪問修飾符加public  
        {  
           System.out.println("母牛愛吃青草");  
        }  
    }  
    class Hen implements Eat //實現接口。  
    {  
        public String name="雞咯咯";       //定義自己的字段  
        public void eat()   //實現接口，注意訪問修飾符加public  
        {  
           System.out.println("母雞愛吃小蟲");  
        }  
    }  
     
public class Example9  
{  
    public static void main(String[] args)  
    {  
        //多態的實現,animalEat代表不同對象，表現出不同的行為  
    Eat animalEat = new Cow(); //注意這種生成實例的方法，此處代表母牛  
        animalEat.eat();          //調用母牛的方法  
        //System.out.println(animalEat.name); //不能訪問  
        animalEat=new Hen();       //注意這種生成實例的方法，此處代表母雞  
        animalEat.eat();          //調用母雞的方法  
        //System.out.println(animalEat.name);//不能訪問  
    }  
}