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

Posted 2020-10-30 fylong

面向对象:

面向对象专注于由谁来解决这个过程,而调用者无需关注对象实现的细节

编程特点: 出现了一个个的类,从类中拿到对象,通过对象直接解决问题

类:具有一系列相同属性(特征)和方法(行为)的个体的集合 称为类

     类是一个抽象的概念,只能说类具有哪些属性而不能直接对类进行赋值

例如 人类有身高这个属性,但是不能说人类的身高是180

  

对象:从类中拿出具有具体属性值的个体,称为对象

    对象是从类中拿出的一个具体的个体,需要对属性进行具体的赋值

例如 人类有身高这个属性,张三是人类的一个个体,就可以说张三身高是180   张三就是人类的一个对象

   

类和对象的关系

1. 类是对象的抽象化,对象是类的具体化
2. 类是对象的描述,对象是类的个体(实例化)
3. 程序中由类产生对象.

 

 

属性的封装(一般使用private关键字实现)

1.将类的属性进行私有化处理,不允许外部程序直接访问,并对外提供统一的方法用于设置和读取私有属性

2.实现访问控制,限制属性访问,但不是拒绝访问

 

封装的作用

只能通过规定的方法访问数据,方便在方法中加入控制语句,防止不合法数据赋值

 

封装:除了属性的封装外,将需要重复使用的代码提取到方法中,这叫方法的封装

将相同的属性和方法抽象成一个类,这也是封装的思想

 

private  int  age;
    
    public void setAge( int age) {
        if (age>0&&age<100) {
            this.age=age;
        }else {
            System.out.println("输入年龄不合法");
            this.age=-1;
        }    
    }
    
    
    public int getAge() {
        return this.age;
    }

set 方法用来赋值      get方法用来读值

并且可以在set方法中设置判断条件,例如上例就是判断年龄是否符合常识

 

类的继承

1. 子类继承父类   使用 extends 关键字

    子类继承父类 不能继承父类的私有属性

 

2.子类中需要访问父类成员,使用super关键字

    super.属性  访问父类属性

    super.方法() 访问父类方法

 

如果,子类中没有同名的属性和方法覆盖父类,则依然可以直接使用this.属性调用从父类中继承的非私有属性

如果,子类中有同名的属性和方法,this.属性访问的是本类   super.属性访问的是父类的属性

在子类的构造函数中,直接使用super() 表示调用父类构造  而且super()函数必须在子类构造的第一行

        

注意 即使使用super关键字 也不能使用父类的私有属性和私有方法

          

3.子类可以访问父类的哪些属性

 

        ①private 　   本类

         

        ②默认() 　　本类 　　本包

          

        ③protected   本类 　　本包 　　非同包子类

          

        ④public  　   本类 　　本包 　　非同包子类        其他包

          

          

           子类可以访问父类的构造方法

         

 4.继承后的初始化顺序

1.            父类属性
2.            父类构造方法
3.            子类属性
4.            子类构造方法

   5.使用继承可以： ①提高代码的复用性，子类可以调用父类非私有的属性和方法，不用再次编写。

　　　　　　　　　②提高代码的维护性。

　　　　　　　　　③将类与类联系起来，是多态的前提。

     

 继承只能单继承,不能多重继承,但是可以多层继承    

 

          public class a;
          
            public class a2 extends   a;
          
            public class a3 extends   a2;

  此时,a3就得到了a和a2两个类的非私有属性

 

多态

同一种事物,由于条件不同,产生不同的结果

 

程序中的多态

同一个引用类型,由于使用不同的对象实例而执行不同的操作

Chinese c=new chinese(); c.say();
english e=new english(); e.say();

英国人说英语,中国人说中文   这不叫多态

 

person p=new chinese();        p.say();
person p=new english();         p.say();

同样是人  有人说英语,有人说中文    这叫多态

 

 

实现多态的条件

①子类继承父类

②子类重写父类方法

③父类引用指向子类对象     保证了同一个父类引用类型,使用不同的子类对象实例,而执行不同的操作

 

abstract关键字

抽象类

使用abstract关键字修饰的类,称为抽象类

抽象类.不能被实例化

 

抽象方法  

使用abstract关键字修饰,而且没有方法体的方法,称为抽象方法

抽象方法.子类继承抽象类,那么,子类必须重写父类的所有抽象方法,除非子类也是抽象类

 

抽象方法必须写在抽象类中

抽象类中的方法不一定是抽象方法

 

例题:

请编码实现如下需求：
  乐器（Instrument）分为：钢琴(Piano)、小提琴(Violin) 乐器（Instrument）包含品牌（brand）、重量（weight）,
 钢琴(Piano)还包含尺寸（size）,小提琴(Violin) )还包含长度(length)

 各种乐器的弹奏（ play ）方法各不相同
 

在做类似题目时,最好按照以下步骤

1. 发现类
2. 发现类的属性
3. 发现类的方法

建一个父类(Instrument类  Instrument类有两个属性:品牌（brand）、重量（weight）以及一个抽象方法:弹奏（ play ）方法)

  public abstract class Instrument{


    private String brand;
    private String weight;
    public abstract void play();
    
    
    public Instrument() {
        super();
   　　　　　}
    public Instrument(String brand, String weight) {
        super();
        this.brand = brand;
        this.weight = weight;    
    　　　　}


    public String getBrand() {
        return brand;
   　　 }
    public void setBrand(String brand) {
        this.brand = brand;
   　　 }
    public String getWeight() {
        return weight;
    　　}
    public void setWeight(String weight) {
        this.weight = weight;
    　　}

}

建两个子类(钢琴(Piano)、小提琴(Violin))

 

钢琴(Piano)类中有私有属性尺寸（size）

public class Piano extends Instrument{


    private String size;
    
    public String getSize() {
        return size;
    }
    public void setSize(String size) {
        this.size = size;
    }


    public Piano(String size) {
        super();
        this.size = size;
    }
    public Piano() {
        super();
    }
    @Override
    public void play() {
        // TODO Auto-generated method stub
        System.out.println("演奏家弹钢琴");

    }
}

小提琴(Violin)类中有私有属性长度(length)

public class Violin extends Instrument {

    
    private String length;
    

    public String getLength() {
        return length;
    }
    public void setLength(String length) {
        this.length = length;
    }
    
    public Violin(String length) {
        super();
        this.length = length;
    }
    public Violin() {
        super();
    }
    @Override
    public void play() {
        // TODO Auto-generated method stub
         System.out.println("演奏家拉小提琴");

    }
}
    

建一个多态类

演奏家  (演奏方法)

public class Performer {
    
    
    public void make(Instrument p) {
        p.play();
                
    }
 }
    

最后建一个测试类

 

public static void main(String[] args) {
        
        Performer t=new Performer();
        t.make(new  Piano());
        t.make(new Violin());
        
        
        
        
        
    }

运行结果为: