java 经典面向对象9个实例

1.hello world 程序

public class FirstDemo {
    public static void main(String[] args){
        System.out.println("Hello World!");
    }
}

2.类的基本组成示例

public class TwoDemo {
    public static void main(String[] args){
        Person p=new Person();      //调用类的无参构造函数
        p.age=20;       //给对象的公有字段直接赋值
        p.setName("zhang shan");        //必须使用公共方法才能给对象的属性赋值
        System.out.println("第一个人信息,姓名:"+p.getName()+"年龄:"+p.age);
        p.eat();    //调用对象的无参方法
        Person p2=new Person(18,"li can");      //调用类的有参构造函数
        System.out.println("第二个人信息,姓名:"+p2.getName()+"年龄:"+p2.age);
        p2.eat("馒头");       //调用对象的有参方法
    }
}

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){
        System.out.println("Person can eat"+s);     //定义带参数的eat方法,实现方法重载
    }
    public Person(){    //定义无参构造函数,注意无返回值定义,方法与类同名

    }
    public Person(int age,String name){//重写一个带参数构造函数,注意无返回值定义,方法与类同名
        this.age=age;//前一个age为对象的字段,由this指定,后一个age为函数形参
        this.name=name; //前一个name为对象的属性,由this指定,因为在本类中可直接访问,后一个name为函数形参
    }

}

3.静态与非静态变量及方法的使用

public class ThreeDemo {
    public int x; //非静态变量
    public static int y; //静态变量
    void method(){//非静态方法
        x=1;//正确,非静态方法可以访问非静态成员
        y=2; //正确，非静态方法可以访问静态成员
        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){
        ThreeDemo t=new ThreeDemo();//生成类的实例
        t.method();//非静态方法通过实例来调用
        ThreeDemo.smethod();//静态方法通过类名来调用
    }

}

4.类继承的例子

public class FourDemo {
    public static void main(String[] args){
        boy b=new boy();
        boy.sex="man";//静态变量的继承
        System.out.println("继承而来的字段sex的值为："+boy.sex);
        b.method1();//来自父类的方法
        b.method2();//自己改写后的方法
        mother m=new mother();
        m.method2();//来自父类的方法

    }
}

class mother{
    public static String sex;
    public void method1(){
        System.out.println("母亲的方法1!");
    }
    public void method2(){
        System.out.println("母亲的方法2!");
    }
}
class boy extends mother{
    public void method2(){
        System.out.println("我自己的方法2!");
    }
}

5.类的访问修饰符

public class FiveDemo {
    public static void main(String[] args){
        program1 p1=new program1();
        p1.method1();
        program2 p2=new program2();
        p2.method2();

        program3 p3=new program3();
        p3.method1();
        p3.method3();


    }
}
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 p1=new program1();
        p1.a=2;
        p1.b=2;//正确
        p1.c=2;  // 正确，在同一个程序集里都可以访问
//        p1.d=2; //错误，只能在它的类的内部访问
        System.out.println("a="+p1.a+"b="+p1.b+"c="+p1.c);
    }
}
class program3 extends program1{
    public void method3(){
        program2 p2=new program2();
        p2.method2();
        b=4; //正确，保护成员可以在它的继承类里访问
        System.out.println("子类可以访问受保护成员b="+b);

    }
}

6.抽象类及其实现示例

public class SixDemo {
    public static void main(String[] args){
        man m=new man();
        m.sex="man";
        System.out.println(m.sex);
        m.method();//调用man类中的方法

    }
}
//应该注意的是：继承抽象类的类，要求抽象类中的抽象方法要被实例化
abstract class personClass{//抽象类
    public String sex;//变量。
    public abstract void method(); //抽象方法。但不能有方法体{}

}
class man extends personClass{ //继承抽象类
    public void method(){//抽象方法的实例化
        System.out.println("继承抽象类的方法被实例化了");
    }

}

7.接口及其实现

public class SevenDemo implements Interface{//实现接口
    int a=12;
    public void method(){//接口的方法在此必须被重写，注意访问修饰符为public
        System.out.println("接口实现成功！！！");
    }

    public static void main(String[] args){
        SevenDemo sd=new SevenDemo();
        System.out.println(sd.a);//只能访问SevenDemo类下的成员变量
        sd.method();
    }
}

interface Interface{//定义一个接口
    int a=10;
    final int b=11; //定义的变量为fianal类型；
    void method();// 声明接口方法，但不能有方法体{}

}

8.抽象类与接口混合编程例子

interface Myinterface{//定义一个接口
    void method1();

}
abstract class abstractClass{//定义一个抽象类
    abstract void method2();//加abstract
}

class shixianlei extends abstractClass implements Myinterface{//继承抽象类，实现接口。
    public String s; //定义自己的字段
    public void method1(){ //实现接口，注意访问修饰符加public
        System.out.println("接口方法已加public实现");
    }
    void method2(){//实现抽象方法
        System.out.println("抽象类方法已实现");
    }
}

public class EightDemo {
    public static void main(String[] args){
        shixianlei sxl=new shixianlei();
        sxl.s="实现类的字段";
        System.out.println(sxl.s);
        sxl.method1();
        sxl.method2();

    }
}

9.接口回调与多态性

interface Eat{//定义一个接口
    void eat();
}
class Cow implements Eat{//实现接口。
    String name="牛哞哞"; //定义自己的字段
    public void eat(){//实现接口，注意访问修饰符加public
        System.out.println("母牛爱吃青草");
    }
}
class Hen implements Eat{//实现接口。
    String name="鸡咯咯"; //定义自己的字段
    public void eat(){//实现接口，注意访问修饰符加public
        System.out.println("母鸡爱吃小虫");
    }
}

public class NineDemo {
    public static void main(String[] args){
        //多态的实现,t代表不同对象，表现出不同的行为
        Eat t=new Cow(); //注意这种生成实例的方法，此处代表母牛
        t.eat(); //调用母牛的方法
        //System.out.println(t.name); //不能访问
        t=new Hen(); //注意这种生成实例的方法，此处代表母鸡
        t.eat(); //调用母鸡的方法
        //System.out.println(t.name);//不能访问

    }
}