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

面向对象:

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

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

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

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

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

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

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

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

类和对象的关系

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

属性的封装(一般使用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.继承后的初始化顺序

父类属性
父类构造方法
子类属性
子类构造方法

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 ）方法各不相同

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

发现类
发现类的属性
发现类的方法

建一个父类(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());
        
        
        
        
        
    }

运行结果为:

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

秒客网

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

相关文章

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

相关文章

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