码迷,mamicode.com
首页 > 其他好文 > 详细

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

时间:2018-04-08 20:15:14      阅读:174      评论:0      收藏:0      [点我收藏+]

标签:person   不同的   哪些   super关键字   for   除了   构造   eth   封装   

面向对象:
面向对象专注于由谁来解决这个过程,而调用者无需关注对象实现的细节
编程特点: 出现了一个个的类,从类中拿到对象,通过对象直接解决问题

类:具有一系列相同属性(特征)和方法(行为)的个体的集合 称为类
     类是一个抽象的概念,只能说类具有哪些属性而不能直接对类进行赋值
例如 人类有身高这个属性,但是不能说人类的身高是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());
        
        
        
        
        
    }

运行结果为:

技术分享图片

 

 
 

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

标签:person   不同的   哪些   super关键字   for   除了   构造   eth   封装   

原文地址:https://www.cnblogs.com/fylong/p/8745991.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!