Java面向对象练习

1、面向对象的类定义、对象实例化、修改属性和引用对象。

package firstproject;
//定义一个car类
class Car
{
    //描述颜色
    String color="blue";
    //描述轮胎数
    int n=4;
    //描述行为
    void run()
    {
        System.out.println("The car is running!");
    }
}
public class CarDemo 
{    
    public static void main(String[] args)
    {
        //实例化车对象
        Car c=new Car();
        //修改车的颜色属性
        c.color="green";
        System.out.println(c.color);
        c.run();
        Car c1=new Car();
        System.out.println(c1.color);
        
        //多个引用，同一个对象
        Car c2=new Car();
        Car c3=new Car();
        c2.color="black";
        c3=c2;
        c3.n=5;
        System.out.println(c2.n);
    }
    
}

2、匿名对象当作实参。

package firstproject;
//定义一个car类
class Car
{
    //描述颜色
    String color="blue";
    //描述轮胎数
    int n=4;
    //描述行为
    void run()
    {
        System.out.println("The car is running!");
    }
}
public class CarDemo 
{    
    public static void main(String[] args)
    {
        //对象当作实参
        Car c=new Car();
        r(c);
        //匿名对象当作实参
        r(new Car());
    }
    public static void r(Car c)
    {
        c.color="red";
        c.n=3;
        c.run();
    }
}

 3、利用private修饰符、set函数和get函数实现封装

package firstproject;
public class People
{
    public static void main(String[] args)
    {
        P p1=new P();
      //p1.age=44;
        p1.set_Age(23);
        System.out.println(p1.get_Age());
    }
}
//定义一个人的类
class P
{
    private int age;                //程序运行过程中，自始至终都没有变化过
    public void set_Age(int age)    
    {
        this.age=age;                //左边的age是private修饰过的age
    }
    public int get_Age()
    {
        return age;
    }
    void speak()
    {
        System.out.println("I will talk !");
    }
}

 4、继承、封装

/*
 * 继承、多态练习
 */
public class Test 
{
    public static void main(String[] args) 
    {
        //zi a=new zi();
        //System.out.println("a.num1="+a.num+"
"+"a.num2="+a.num);
        //a.show();
        //a.show1();
        zi b=new zi();
        System.out.println(b.num);
        System.out.println(Person.MY_PAI);
    }
}

//子类调用父类的构造函数
class fu
{
    int num=8;
    fu()
    {
        num=43;
        System.out.println("fei yada");
    }
    fu(int x)
    {
        System.out.println("fei yada");
    }
}
class zi extends fu
{
    zi()
    {
        super();                //默认调用父类的构造函数
        //super(4);
        System.out.println("lang wei");
    }
}

//子类调用父类的函数和成员变量
class fu1
{
    int num=23;
    public void show()
    {
        System.out.println(num);
    }
}
class zi1 extends fu1
{

    int num=32;
    public void show()                 //覆盖重写父类功能
    {
        //super.show();            //调用父类的方法
        System.out.println(this.num);
        System.out.println(super.num);
        
    }
}
/*
 * 子类调用父类的构造方法和一般方法的方式
 */
class Person
{
    public static final double MY_PAI=3.141592653;     //最终成员变量不允许二次赋值，它是一个常量
    private String name;
    Person(String name)
    {
        this.name=name;
    }
    void run(){}
}
class Student extends Person
{
    String name;
    Student(String name)
    {
        super(name);
    }
    void run()
    {
        super.run();
    }
}

5、构造函数，一般函数、属性构造器、构造代码快和this关键字的使用

 1 package firstproject;
 2 public class People
 3 {
 4     public static void main(String[] args)
 5     {
 6         P p1=new P();                   //构造函数，只被对象调用一次
 7         P p2=new P("Joe Shine",23);
 8         System.out.println("之前的姓名是： "+p2.get_Name());
 9         p2.set_Name("Joe");
10         System.out.println("之后的名字是： "+p2.get_Name());
11         P p3=new P(23);
12         P.cry();                       //一般函数，可以被对象调用多次
13         P p4=new P("xiaowang");           //实例化两个人，比较两个人的名字是否相同
14         P p5=new P("daming");
15         boolean b=p4.compare(p5);
16         System.out.println(b);
17     }
18 }
19 //定义一个人的类
20 class P
21 {
22     private String name;
23     private int age;
24     
25     public void set_Name(String name) //属性构造器
26     {
27         this.name=name;
28     }
29     public String get_Name()
30     {
31         return name;
32     }
33     
34     public void set_Age(int age)     //属性构造器
35     {
36         this.age=age;
37     }
38     public int get_Age()
39     {
40         return age;
41     }
42     //定义多种构造函数
43     P()
44     {
45         System.out.println("name="+name+",age="+age);
46     }
47     P(String name)
48     {
49         this.name=name;
50     }
51     P(String name,int age)
52     {
53         this(name);                        //this用在构造函数间调用
54         this.age=age;
55         System.out.println("name="+name+",age="+age);
56     }
57     P(int age)  
58     {
59         this.age=age;
60         System.out.println("age="+age);
61     }
62     static void cry()
63     {
64         System.out.println("cry....");
65     }
66     //构造代码块
67     {
68         System.out.println("优先执行！！！");
69     }
70     //设计函数，比较两个人的人名是否相同，使用this关键字调用对象
71     public boolean compare(P p)
72     {
73         return this.name==p.name;
74     }
75 }

6、抽象、继承特性练习

/*
 * 抽象、继承练习
 */
class BaseStudent extends Student
{
    void study()
    {
        System.out.println("Base study");
    }
    void learn(){}                //子类中必须实现父抽象类中的所有方法
}
class AdvanStudent extends Student
{
    void study()
    {
        System.out.println("Advance study");
    }
    void learn(){}
}
abstract class Student            //抽象方法只能在抽象类中
{
    abstract void study();
    abstract void learn();
}

/* 实例：
 * 假如我们开发一个系统是需要对员工进行建模，员工包括三个属性：姓名、工资和工号。经理也是员工，除了具有员工的属性外，
 * 还具有奖金属性。请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。
 */

//主函数
public class Test 
{
    public static void main(String[] args) 
    {
        //BaseStudent stu1=new BaseStudent(); 
        //stu1.study();
        Manager m1=new Manager("zhangsan","092238984",5000,400);
        Employee e1=new Employee("lisi","0123454",500);
        System.out.println(m1.getName());
        System.out.println(e1.getName());
        m1.work();
        e1.work();
    }
}
//定义打工者，它是一个抽象类
abstract class Staff 
{
    //声明私有的成员变量
    private String name;
    private String id;
    private double pay;
    //抽象类内部可以有构造方法
    Staff(String name,String id,double pay) 
    {
        this.name=name;
        this.id=id;
        this.pay=pay;
    }
    //属性构造器
    public void setName(String name)
    {
        this.name=name;
    }
    public String getName()
    {
        return name;
    }
    public void setId(String id)
    {
        this.id=id;
    }
    public String getId()
    {
        return id;
    }
    public void setPay(double pay)
    {
        this.pay=pay;
    }
    public double getPay()
    {
        return pay;
    }
    
    //定义抽象的成员方法
    abstract void work();
}
//员工类
class Employee extends Staff
{
    Employee(String name,String id,double pay)
    {
        super(name, id, pay);
    }
    void work()
    {
        System.out.println("员工工作内容");
    }
}
//经理类
class Manager extends Staff
{
    private int bonus;
    Manager(String name,String id,double pay,int bonus)
    {
        super(name,id,pay);
        this.bonus=bonus;
    }
    public int getBonus() 
    {
        return bonus;
    }
    public void setBonus(int bonus)
    {
        this.bonus = bonus;
    }
    void work()
    {
        System.out.println("经理工作内容");
    }
}

 7、模版方法设计模式例子

/*
 * 实例：设计程序得出程序运行的时间
 * 思路：利用System.currentTimeMillis();函数
 */
public class Test extends Code
{
    public static void main(String[] args) 
    {
        Code a=new Code();
        a.runcode();
    }
}
abstract class GetTime
{
    public final void getTime()   //定义为最终类，确保获取时间的方法不可以复写
    {
        long start=System.currentTimeMillis();
        runcode();
        long end=System.currentTimeMillis();
        System.out.println("
运行时间是："+(end-start)+"毫秒");
    }
    abstract void runcode();
}
class Code extends GetTime
{
    void runcode()
    {
        
    }
}

 8、多态的扩展性

/*
多态性扩展性的实例
 */
public class InterfaceDemo
{
    public static void main(String[] args) 
    {
        /*
        Cat c=new Cat();
        c.eat();
        Dog d=new Dog();
        d.eat();
        Pig p=new Pig();
        p.eat();
        */
        /*
        chi(new Dog());
        chi(new Pig());
        chi(new Cat());
        Cat c=new Cat();
        chi(c);
        System.out.println();
        */
        //多态性概念
        Animal c1=new Cat();
        c1.eat();
        Animal d1=new Dog();
        d1.eat();
        Animal p1=new Pig();
        p1.eat();
        System.out.println();
        //多态性的扩展性表现
        chi(new Cat());
        chi(new Dog());
        chi(new Pig());
        
    }
    //体现封装性的函数
    public static void chi(Cat c)
    {
        c.eat();
    }
    public static void chi(Dog d)
    {
        d.eat();
    }
    public static void chi(Pig p)
    {
        p.eat();
    }
    //表现多态性的函数
    public static void chi(Animal a)
    {
        a.eat();
    }
}
/*
 定义一个父类：动物
     子类：猫，狗，猪
 */
abstract class Animal
{
    public abstract void eat();
}
class Cat extends Animal
{
    public void eat()
    {
        System.out.println("吃鱼");        
    }
    public void catchMouse()
    {
        System.out.println("抓老鼠");
    }
}
class Dog extends Animal
{
    public void eat()
    {
        System.out.println("吃骨头");
    }
    public void kanjia()
    {
        System.out.println("看家");
    }
}
class Pig extends Animal 
{
    public void eat()
    {
        System.out.println("吃草");
    }
}

 9、多态的转型

/*
多态性转型的实例
 */
public class InterfaceDemo
{
    public static void main(String[] args) 
    {
        //多态性概念
        /*
        Animal c=new Cat();  //类型提升，向上转型
        c.eat();
        Cat c1=(Cat)c;        //强制向下转型,否则无法使用特定方法
        c1.catchMouse();
        */
        chi(new Cat());
        chi(new Dog());
        chi(new Pig());
    }
    //表现多态性的函数
    public static void chi(Animal a)   //子类型有限用此方法
    {
        a.eat();              //吃的食物的类型
        if(a instanceof Cat)
        {
            Cat c=(Cat)a;      //将a对象的从父类强制转型为子类Cat对象
            c.catchMouse();
        }
        else if(a instanceof Dog)
        {
            Dog d=(Dog)a;
            d.kanjia();
        }
        else 
            System.out.println("猪的特定类型是睡觉");
    }
}
/*
 定义一个父类：动物
     子类：猫，狗，猪
 */
abstract class Animal
{
    public abstract void eat();
}
class Cat extends Animal
{
    public void eat()
    {
        System.out.println("吃鱼");        
    }
    public void catchMouse()
    {
        System.out.println("抓老鼠");
    }
}
class Dog extends Animal
{
    public void eat()
    {
        System.out.println("吃骨头");
    }
    public void kanjia()
    {
        System.out.println("看家");
    }
}
class Pig extends Animal 
{
    public void eat()
    {
        System.out.println("吃草");
    }
    public void sleep()
    {
        System.out.println("睡觉");
    }
}

 10、多态扩展性例子练习

/*
多态性练习：对一个培训班的基础班，提高班，冲刺班的所有学员面向对象编程,学员共有的方法是吃饭和睡觉,睡觉需要重写。
 思路：1、定义一个抽象的学生类；
     2、利用多态性将多个班的学生方法抽象出来，对外提供所有学生共有特性的的访问接口，通过定义方法类来实现；
     3、分别定义学生类的子类：基础班学生，提高班学生，冲刺班学生；
     4、调用方法类，实例化学员对象。
 */
public class InterfaceDemo
{
    public static void main(String[] args) 
    {
        FunStudent f=new FunStudent();
        f.fun(new BaseStudent());
        f.fun(new AdvStudent());
        f.fun(new SprintStudent());
    }

}
//定义抽象的父类
abstract class Student
{
    public abstract void study();  //子类必须实现的方法
    public void sleep()
    {
        System.out.println("躺着睡");
    }
}
//定义方法类
class FunStudent
{
    public void fun(Student s)
    {
        s.study();
        s.sleep();
    }
}
//定义子类
class BaseStudent extends Student
{
    public void study()
    {
        System.out.println("base study");
    }
    public void sleep()
    {
        System.out.println("站着睡");
    }
}
class AdvStudent extends Student
{
    public void study()
    {
        System.out.println("Adv study");
    }
}
class SprintStudent extends Student
{
    public void study()
    {
        System.out.println("sprint study");
    }
}

11、接口多态的逻辑练习

/*
接口多态的逻辑练习：电脑主板，接口，各种外插卡
 */
public class Test
{
    public static void main(String[] args) 
    {
        MainBoard mb=new MainBoard();
        mb.run();
        mb.P(new NetCard());
        mb.P(new SoundCard());
        mb.P(null);       //主板没有插任何东西
    }

}
//定义一个主板类
class MainBoard
{
    public void run()
    {
        System.out.println("主板在运行");
    }
    //接口的多态性
    public void P(PCI p)
    {
        if(p!=null)
        {
            p.open();
            p.close();
        }
    }
}
//定义一个接口
interface PCI
{
    public abstract void open();
    public abstract void close();
}
//定义一个网卡,执行接口
class NetCard implements PCI
{
    public void open()
    {
        System.out.println("NetCard open");
    }
    public void close()
    {
        System.out.println("NetCard close");
    }
}
//定义一个声卡，执行接口
class SoundCard implements PCI
{
    public void open()
    {
        System.out.println("SoundCard open");
    }
    public void close()
    {
        System.out.println("SoundCard close");
    }
}

12、Object 练习

/*
Object类练习
 */
public class Test
{
    public static void main(String[] args) 
    {
        Demo d=new Demo(4);
        Demo d1=new Demo(5);
        Person p=new Person();
        System.out.println(d.toString());
        System.out.println(Integer.toHexString(d.hashCode()));
        System.out.println(p.toString()); 
        Class a=p.getClass();
        System.out.println(a.getName());
    }
}
class Person
{}
class Demo
{
    private int num;
    Demo(int x)
    {
        this.num=x;
    }
    //对象比较功能在父类Object中存在，所以就重写父类方法即可
    public boolean equals(Object obj)  //Object obj=new Demo();
    {
        Demo o=(Demo)obj;
        return this.num==o.num;
    }
}

 13、内部类练习1

/*
内部类练习1
 */
public class Test
{
    public static void main(String[] args) 
    {
        Outer o=new Outer();
        //Outer.Inner i=new Outer().new Inner();  
        //new Outer.Inner().function();  //访问内部静态类方法
        Outer.Inner.function();
        o.method();
        //i.function();
        //Inner i=new Inner();        //错误
        System.out.println();
    }
}
class People
{}

class Outer //外部类
{
    private static int a=4;
    static class Inner  //内部类
    {
        static void function()
        {
            System.out.println("我是内部类");
            System.out.println(a);
        }
    }
    void method()
    {
        Inner.function();
        a=32;
        //Inner i=new Inner();
        //i.function();
        System.out.println("我是外部类的方法");
    }
}

 14、内部类练习2

/*
内部类练习2
 */
public class Test
{
    public static void main(String[] args) 
    {
        //new Outer().method();    //实例化内部类才可以使用此语句
        Outer.method();
    }
}
class Outer //外部类
{
    private static int a=2;
    static void method()
    {
        final int b=4;
        final class Inner    //内部类没有定义在成员变量的位置上，不能使用成员变量的修饰符
        {
            void function()
            {
                System.out.println(a);
                System.out.println(b);
            }
        }
        new Inner().function();  //需要实例化内部类
    }
}

15、匿名内部类练习1

/*
匿名内部类练习1
 */
public class Test
{
    public static void main(String[] args) 
    {
        new Outer().method();
    }
}
//定义一个抽象类
abstract class ab
{
    abstract void function();
}
class Outer //外部类
{
    int a=2;
    /*
    class Inner    extends ab   //内部类继承自一个外部的抽象类
    {
        void function()
        {
            System.out.println(a);
        }
    }
    */
    void method()
    {
        //new Inner().function(); 
        //匿名类对象的的建立，此对象等价于注释部分的内容
        /*
        new ab()
        {
            void function()
            {
                System.out.println(a);
            }
            void show()
            {
                System.out.println("我是匿名对象");
            }
        }.function();
        new ab()
        {
            void function()
            {
                System.out.println(a);
            }
            void show()
            {
                System.out.println("我是匿名对象");
            }
        }.show();
        */
        ab x=new ab()
        {
            void function()
            {
                System.out.println(a);
            }
            void show()
            {
                System.out.println("我是匿名对象");
            }
        };
        //x.show();        //编译失败
        x.function();
    }
}    

16、匿名内部类练习2

/*
匿名内部类练习2
 */
public class Test1
{
    public static void main(String[] args) 
    {
        Test.function().method();  //给定的条件
        //在没有父类和接口的情况下，运行一个function方法
        new Object()    //一个Object类的实例对象
        {
            void function()            //给实例对象添加内容
            {
                System.out.println("我是一个奇葩");
            }
        }.function();
    }
}
interface Inter
{
    public abstract void method();
}

class Test
{
    //补足代码，通过匿名内部类
    /*
    static class Inner implements Inter
    {
        public void method()
        {
            System.out.println("我是内部类");
        }
    }
    */
    static Inter function()
    {
        //return new Inner();
        return new Inter()
        {
            public void method()
            {
                System.out.println("我是内部类");
            }
        };
    }
}

 17、自定义异常

/*
自定义异常：建立一个除法类，因为Java系统中没有负数的异常定义，所以需要自定义负数异常。
 */
public class Test1
{
    public static void main(String[] args) 
    {
        Demo d=new Demo();
        try
        {
            d.div(5, -3);
        }
        catch(FuShuException e)
        {
            System.out.print(e.toString());
            //System.out.println(e.getMessage());
            System.out.println(e.fuShu());
        }
        System.out.println();
    }
}
class Demo
{
    int div(int x,int y) throws FuShuException //可能出现问题，抛出负数异常
    {
        if(y<0)
            throw new FuShuException("算数中出现了负数，不满足条件！负数是：",y); //抛出一个负数异常对象
        return x/y;    
    }
}
//自定义异常类
class FuShuException extends Exception //自定义异常类继承自Exceptionl类
{
    private int a;    //负数值
    FuShuException(String msg,int a)
    {
        super(msg);
        this.a=a;
    }
    int fuShu()
    {
        return a;
    }

}

 18、异常的练习

/*
通过异常处理写出一个老师使用电脑授课，电脑出现异常对老师授课产生影响的程序
 */
public class ExceptionTest
{
    public static void main(String[] args) 
    {
        Teacher t=new Teacher("李老师");
        try
        {
            t.prelect();
        }
        catch(StopPrelect e)
        {
            System.out.println(e.toString()+"开始做练习");
        }
    }
}
//定义一个老师类
class Teacher
{
    String msg;
    private Computer com;
    Teacher(String msg)
    {
        this.msg=msg;
        com=new Computer(); //com指向Computer类的引用初始化成功，就说明电脑可以正常使用
    }
    public void prelect() throws StopPrelect
    {
        try
        {
            com.run();
        }
        catch(LanPingException e)  //解决蓝屏异常
        {
            System.out.println(e.toString());
            com.reset();
            System.out.println("老师修复了蓝屏异常"+"
正常上课");
        }
        catch(MaoYanException e)  //无法解决冒烟异常，再次抛出
        {
            System.out.println(e.toString()+"
老师无法修复电脑");
            throw new StopPrelect("停止上课");
        }
    }
}
//定义一个电脑类
class Computer
{
    private String state="运行错1"; //定义一个电脑的状态变量，正常运行
    public String stateArgument()
    {
        return state;
    }
    public void run() throws LanPingException,MaoYanException  //声明两个异常，需要去解决
    {    
        if(state=="正常运行")
            System.out.println("电脑正常运行");
        else if(state=="运行错误1")
            throw new LanPingException("出现了蓝屏异常");  //抛出一个蓝屏异常对象
        else if(state=="运行错误2")
            throw new MaoYanException("出现了冒烟异常");    //抛出一个冒烟异常
        else
            System.out.println("电脑有其它运行错误"+"
停止授课");
    }
    public void reset()
    {
        System.out.println("电脑在重启");
    }
}
//定义一个蓝屏异常
class LanPingException extends Exception
{
    //private String message;
    static final long serialVersionUID=1L;
    LanPingException(String message)
    {
        super(message);
    }
}
//定义一个冒烟异常
class MaoYanException extends Exception
{
    //private String message;
    static final long serialVersionUID=2L;
    MaoYanException(String message)
    {
        super(message);
    }
}
//定义一个无法授课的异常
class StopPrelect extends Exception
{
    //private String message;
    static final long serialVersionUID=3L;
    StopPrelect(String message)
    {
        super(message);
    }
}

19、

说明：代码基本上是从毕向东老师那里学来的。