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);//不能访问  
    }  
}