面向对象总结

好像直接奔总结了,经常偷懒只能总结全点............

封装,继承,多态面向对象的三大特征

封装思想

• 就是把字段和方法单独存放在一个独立的模块内
• 信息隐藏,尽可能隐藏对象的数据和功能实现细节

好处:

• 保证数据的安全性,防止调用者随意修改数据
• 提高组件的重用性

这就不得不提到JavaBean规范

public class Preson{//必须以public修饰类
    private string  name;//成员变量必须以private(私有化),提供getter和setter方法
    private int age;

        public Preson(){}//提供无参构造
        public Preson(String name,int age){//提供有参构造
          this.name=name;
          this.age=age;
     }
         public String getName() {
        return name;
    }
    public void setName(String n) {
        name = n;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int a) {
        if(a < 0) {
            System.out.println("非法的年龄");
            return;
        }
        age = a;
    }
}    

继承

当有多个类使用重复代码时,抽取为一个父类.

public class Person{//子类继承并不会继承父类的构造器,以及成员变量  private String name;

private int age;

   public Person(){}
   public Person(String name,int age){
         this.name=name;
         this.age=age;  
   }

        public void rest() {
        System.out.println("休息");
    }
    public String getName() {
        return name;
    }
        public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
/*
如果父类中的成员使用public和protected修饰，子类都能继承.
*/

public Student extends Person{}//is a的思想学生是人
public Teacher extends Person{}

但注意继承支持单继承,多重继承

**当父类方法不满足子类需求时,可以重写父类方法!!!!

多态

就是编译类型与运行类型不一致时,就产生了多态

编译类型:声明对象变量的类型,编译类型必须是父类或接口

运行类型:对象真实类型

Dog     d     =     new Dog();      //创建一只狗对象,赋给子类类型变量,运行类型
Animal  a      =    new Cat();        //创建一只猫对象,赋给父类类型变量,编译类型

多态的执行流程

编译时,它会先到父类找方法是否存在,存在则到子类寻找,有就执行子类的方法,没有就执行父类的方法

 

 那假设碰到子类独有的方法呢?

就有了(类型的转换)

//自动类型转换：把子类对象赋给父类变量（多态）
     Animal a = new Dog();
     Object  obj = new Dog();    //Object是所有类的根类
//强制类型转换：把父类类型对象赋给子类类型变量（前提：该对象的真实类型应该是子类类型）
     Animal a = new Dog();
     Dog    d = (Dog) a;    //正确
     Cat      c = (Cat) a;    //错误

那多态到底好处在哪呢?

public class MotherBoard {//每次实现,都需要在主类上写一个方法是否很麻烦?
    //在主板上安装鼠标对象
    public void plugin(Mouse m) {
        m.work1();    //调用鼠标工作的方法
    }
    //在主板上安装键盘对象
    public void plugin(Keyboard k) {
        k.work2();    //调用键盘工作的方法
    }
}

看实例,

当在主类上直接实现了接口的方法后,就不需要重复的在父类写这个方法了

public class Mouse implements IUSB{
    
    public void swapData() {
        System.out.println("鼠标在移动");
    }
}

public class Keyboard implements IUSB{
    
    public void swapData() {
        System.out.println("用键盘打字");
    }
}


public class MotherBoard {
   //IUSB类型可以接受实现类对象
    public void plugin(IUSB usb) {
        usb.swapData();
    }
}


public class USBDemo {
    public static void main(String[] args) {
        // 创建主板对象
        MotherBoard board = new MotherBoard();
        // 创建鼠标对象
        Mouse m = new Mouse();
        // 创建键盘对象
        Keyboard k = new Keyboard();
        //在主板上安装鼠标
        board.plugin(m);
        //在主板上安装键盘
        board.plugin(k);
    }
}

 

接口

制定规范和分离的思想,也是体现组件之间的低耦合思想

public interface I接口名{//接口的命名必须以'I'开头
  //抽象方法1  (抽象方法可以省略,public abstract,而在Java8接口中也可以有实现方法)
  //抽象方法1 
  //抽象方法1 
 default void defaultMethod(){
        System.out.println("有默认实现的方法, 属于对象");
    }
    static void defaultMethod(){
        System.out.println("有默认实现的方法, 属于类");
    }

}

接口时支持多继承的,可以有多个接口

public class A implements 接口名称1,接口名称2...{}

但是当你调用接口成为实现类时,就必须覆盖所有方法,否则就要变为抽象方法

欢迎大家吐槽,虽然应该没人看