oop思想(封装、继承、多态)

封装

n  分析需求，用封装方式设计类，画出类图

u  汽车销售人员销售汽车，可售款式有凯越、君威

Ø 每款汽车有款式和编号，款式、编号不能修改（private）

Ø 汽车销售人员有姓名，姓名不能修改(private)

u  销售人员有两种销售方式：(两种销售方法)

Ø 按车辆销售，每次一辆

Ø 按车型销售（凯越），要同时告诉销售人员购买数量

publicclass Excelle {       private String type;       private String id;       public Excelle(String type,String id){//初始化参数，传递参数            this.type=type;            this.id=id;       }       public String getType() {            returntype;       }       publicvoid setType(String type) {            this.type = type;       }       public String getId() {            returnid;       }       publicvoid setId(String id) {            this.id = id;       }       }

 

 

publicclass Regal {       private String type;       private String id;       public Regal(String type,String id){            this.type=type;            this.id=id;       }       public String getType() {            returntype;       }       publicvoid setType(String type) {            this.type = type;       }       public String getId() {            returnid;       }       publicvoid setId(String id) {            this.id = id;       }       }

 

package com.dt64.java02;   publicclass Seller {       private String name;         public String getName() {            returnname;       }         publicvoid setName(String name) {            this.name = name;       }       //销售的方法       //按类型       publicvoid sell(Excelle ell){            System.out.println(this.name+"正在买的车型："+ell.getType()+"\t编号："+ell.getId());       }       publicvoid sell(Regal rell){            System.out.println(this.name+"正在买的车型："+rell.getType());       }       //按类型和数量       publicvoid sell(Excelle ell,int num){            System.out.println(this.name+"正在买的车型："+ell.getType()+"\t数量是："+num);       } }

 

publicstaticvoid main(String[] args) {         // TODO Auto-generated method stub         Excelle ell=new Excelle("标致206","206");         Regal reg=new Regal("风神A60","A60");         Seller seller=new Seller();         Scanner sc=new Scanner(System.in);         System.out.println("请输入销售员的姓名：");         seller.setName(sc.next());         seller.sell(ell);         seller.sell(ell, 20);     }

继承:遗传(extends) ：抽取共性的属性或方法

抽象:abstract

Constructor call must be the first statement in aconstructor：super();只要涉及到调用构造函数，永远第1句！！！

|-----思考：为什么调用有参的构造方法后，无参的构造方法却不再调用？

|--------调用有参的构造方法，那么无参不会调用（系统） java机制

构造方法作用:初始化对象

|-----重写和重载的区别？

重写：前提条件（有继承关系），发生不同的类中，方法名一致的。子类要重写父类的方法，修饰符不能严于父类的

public class Animal{

         publicvoid say(){//protected

 

         }

}

 

public class Dog extends Animal{

         private void say(){

 

         }

}

public class smallDog extends Dog{

         //say的方法就用不了！

}

	位置	方法名	参数表	返回值	访问修饰符
方法重写	子类	相同	相同	相同或是其子类	不能比父类更严格
方法重载	同类	相同	不相同	无关	无关

 

n  Object类是所有类(包括自定义的类)的父类

 

|------Object也可以被继承

publicclass Animal extends Object{         @Override       publicboolean equals(Object obj) {            // TODO Auto-generated method stub            returnsuper.equals(obj);       }         @Override       public String toString() {            // TODO Auto-generated method stub            returnsuper.toString();       }   }

 

|-----测试类

publicstaticvoid main(String[] args) {            // TODO Auto-generated method stub            Animal an=new Animal();            //Object obj=new Object();             boolean flag= an.equals(an);//传入的就Animal对象，与this比较            System.out.println("结果："+flag);       }

 

 

|----abstract 抽象类有什么作用？

 

 

Abstract methods do not specify a body：抽象方法不能有方法体的

 

 

The abstract method play in type Animal2 can only bedefined by an abstract class：如果一个类中，有抽象方法的话，那么当前的类必须是抽象类

 

The type Dog must implement the inherited abstractmethod Animal.eat()

继承了抽象类，必须重写抽象类（父类的）中抽象方法

 

 

Cannot instantiate the type Animal：抽象类是不能实例化的

|-----抽象类能否有构造方法？ 可以有构造方法，又不能实例化，那么抽象类中的构造方法有什么用？

|------抽象类不能实例化，但是构造方法不是给抽象类实例化用的，给子类用的:当子类在继承的过程中，子类初始化参数过程中，借用抽象类来初始化！

public Dog(String name,int age){            super(name,age);       }

 

|-----抽象类

/**  * @see:抽象类（不具体）  *1：抽象类能有什么东东？  *1.1:放私有属性，公共方法  *1.2:抽象方法  * */ publicabstractclass Animal {       private String name;       privateintage;       public Animal(){                  }       public Animal(String name,int age){            this.name=name;            this.age=age;       }       public String getName() {            returnname;       }       publicvoid setName(String name) {            this.name = name;       }       publicint getAge() {            returnage;       }       publicvoid setAge(int age) {            this.age = age;       }       //可以让子类自已去写这么个业务       publicabstractvoid eat();//抽象方法 }

 

 

|-----子类

publicabstractclass Dog extends Animal{       /*public Dog(String name,int age){            super(name,age);       }*/ }

 

|-----孙类

publicvoid eat() {         Scanner sc=new Scanner(System.in);         System.out.println("请输入小狗名字：");         super.setName(sc.next());         // TODO Auto-generated method stub         System.out.println(super.getName()+"正在吃骨头！");     }

同一种操作，由于条件不同，产生的结果也不同

水（物质）---加热--》水蒸汽

水--制冷---》冰

水

 

多态：同一个引用类型（操作），使用不同的实例(new)而执行不同操作

|------分析：狗类和猫类 统称动物类（abstract）

骨头和鱼统称食物类(abstract)

主人类分配资源 动物类与食物类之间的关系（代码 ： 多态）

 

publicstaticvoid main(String[] args) {         // TODO Auto-generated method stub         Animal an=new Dog();//父类  父类对象=new 子类(); 向上转型         an.showName();//重写的关系         //继续使用an对象（引用类型）         an=new Cat();//父类对象=new 子类（）;向上转型         an.showName();     }

 

|-----多态的前提条件：具有继承关系的 子类重写父类的方法（abstract） 向上转型（父类带子类---不能是子类带父类  转完型后：父类对象）

|-----多态的本质：多个类之间的关系是什么？  多个类之间关系 框架（用java系统(jdk)）

 

|----向下转型

Type mismatch: cannot convert from Food to Bone

 

Cannot cast from Animal to Bone：强制转换（前提条件：只能转换同等类型）

int a=(int)23.4;

关键字instanceof:用于判断对象的具体类型，只能用于引用数据类型判断  通常在向下转型前用于健壮性的判断

public static void method (Animal a){
        a.eat();
    }
    if(a instanceof Cat){
        Cat c=(Cat)a; //向下转型
        c.catchMouse();
    }else if(a instanceof Dog){
        Dog d=(Dog)a;
        d.lookhome();
    }

多态时,成员的特点:

1.成员变量:

编译时：参考引用类型变量所属的类中是否有调用的成员变量，有，编译通过。否则，失败。

运行时：参考引用类型变量所属的类中是否有调用的成员变量，并运行该所属类中的成员变量

简单说:编译和运行都参考等号的左边

2.成员函数(非静态)

编译时：参考引用类型变量所属的类中是否有调用的函数，有 编译通过  否则 失败。

运行时:参考的是对象所属的类中是否有调用的函数。

简单说：编译看左边，运行看右边。

3.静态函数:

编译时：参考引用类型变量所属的类中是否有调用的静态方法

运行时：参考引用类型变量所属的类中是否有调用的静态方法

简单说：编译和运行都看左边