面向对象语言的三大特征

目录

封装

概念:

案例:

应用:

继承

概念

作用

语法

应用场景

传递性

基类

程序中类信息加载

方法重写

概念

语法

重写标签

​编辑抽象类

概念

抽象方法

说明 

多态

    概念

    存在条件

    多态的使用

多态优点:

多态的转型

 final关键字

接口

  概念

 特点

接口的定义和使用

接口的特性

抽象类与接口的区别

成员变量的区别

构造方法的区别

成员方法的区别

类与接口的关系区别


封装


概念:

将类的某些信息隐藏起来(用访问权限修饰符来实现),不让外部直接对其访问,一般可以通过特定的方法来对其隐藏信息的访问,便于控制。

案例:

比如我们设计一个学生类,学生有学号,专业,班级,家庭地址,联系方式等属性,但一般家庭住址和联系方式一般不对外开放,需要对其封装,并设置特定的通道(方法)让其访问。

代码:

public class Student {
    String id;  //没有访问权限修饰符,默认为default
    String name;
    String grade;
    private String address; //此属性用private修饰,只有在此类中可以访问,实现封装效果.
    private String Tel;

    /**
     *  此方法不用public修饰,对外提供访问地址的方法,
     *  外界只有通过此方法才可以访问到学生地址
     */
    public String getAddress() {
        return address;
    }

    public String getTel() {
        return Tel;
    }
}

应用:

比如我们有这样一个需求: 让一个类在一个程序中,只能创建一个对象。

我们可以将这个类的构造方法设置私有权限,这样这个构造方法在其他类中无法随便使用,在此类中提供一个创建对象的方法,并且控制其次数,这样就解决问题了。

继承


概念

    由子类继承父类,子类可以访问父类允许的访问的属性,方法,代码块。

作用

    可以实现代码重复利用

语法

 使用extends关键字 

 class 类1 extends 类2{}

 表示类1继承了类2

应用场景

不是任意俩个类就可以继承,继承的俩个类必须是同一类事物,并且级别不同,这时级别低的可以继承级别高的类。比如说我们不能让一只猫继承车,因为猫和车不属于一个类,没有共同属性、特征和功能;也不能让猫继承狗,虽然看起来他们好像有联系,属于同一类,但它们是俩种独立的个体,没有依赖关系,级别相同,不能继承。

但我们可以让猫继承动物,狗也可以继承动物,动物包括猫和狗,他们级别不同,但它们有共同属性和功能:动物都有姓名,品种,年龄等属性,都会吃饭,走等功能。猫和狗可以使用动物的属性和方法,也可以重写方法。

传递性

一个类只能直接继承一个父类,继承后子类就可以使用父类非私有的成员。

继承也具有传递性 :  C继承B  B继承A 那么C就可以使用A和B中的非私有成员。

基类

当一个类没有显示继承某个类,那么这个类默认继承Object类,Object类是所有类的“祖先”,也就是基类。

程序中类信息加载

在创建子类对象后,调用构造方法,从上向下的调用,先初始化父类信息,子类就可以使用这些信息了。

super()方法表示调用父类的无参构造方法,默认存储在子类构造方法的第一行。

方法重写

概念

     父类中的实现方式不能满足子类的需求,子类可以定义自己实现方式。

语法

 ●方法名相同

 ●参数列表相同

 ●返回值相同

 ●访问权限修饰符不能比父类的权限小

重写标签

@Override 这是java中提供的一个注解标签(是一种标记,记号),添加此注解的标签表示此方法是从父类中重写过来的,会对其进行验证。

代码:

public class Animal {
    String name;
    int    age;
    String species;

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getSpecies() {
        return species;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setSpecies(String species) {
        this.species = species;
    }

    public void run() {
        System.out.println("跑");
    }

    public void eat() {
        System.out.println("吃");
    }
}
public class Cat extends Animal{

    @Override  //方法重写标签
    /**
     * 方法名与父类一致
     * 参数列表与父类一致
     * 返回值类型与父类一致
     * 访问权限修饰符和父类一样(不能比父类小)
     */
    public void eat(){
        System.out.println("猫吃饭");
    }

    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.setName("凯奇");
        cat.setAge(12);

        cat.run(); //cat类没有定义此方法,可以调用父类的方法
        cat.eat(); //Cat类重写了此方法,优先调用本类的方法

    }

}

运行结果

面向对象语言的三大特征_第1张图片抽象类


概念

     如果一个类中包含足够多的信息(抽象方法)来描绘一个具体的对象,这样的类就是抽象类。

抽象方法

     是一种特殊的方法,只有声明,没有实现体。适用于只知道有此功能,但不知道具体的实现方式,则可以定义为抽象方法,由其子类具体实现。

    abstract  抽象  用 abstract 修饰的方法是抽象方法,没有方法体。

                            一般用在靠顶层的类,这些类与子类的实现大有不同。

                             abstract 修饰的类是抽象类,其中可能包含抽象方法。

说明 

    抽象类不能创建对象,因为它含有抽象方法,其他功能与类相同。

    抽象类主要用于体系结构上层,用来定义功能。

多态


    概念

          同一种事物,在不同时刻表现不同的状态。

    存在条件

          ●要有继承关系(类继承类,类继承抽象类,类实现接口)

          ●要有重写方法

          ●父类的引用执行子类的对象

  前俩个为前提条件

    多态的使用

代码:

Animal a = new Dog();  //Dog 是Animal的子类,创建的Dog对象自动向上转型,变为Animal类型
a.eat();

编译期间 a.eat() a的类型是Animal类,调用Animal类的eat()

运行期间 a指的是Dog对象,运行的是Dog中重写的eat()

针对于非静态成员方法:

       编译期间看左边,运行期间看右边

针对于静态成员变量,成员方法:

       编译期间看左边,运行期间也看左边

  说明:因为静态的信息只有一份,且随着类的加载而加载,创建对象时,静态信息不会加载到对象中。

多态优点:

   体现程序的扩展性

多态的转型

     自动转型 :

           子类继承父类(向上转型:子类型会自动转为父类类型)

     强制转型 : 

           向下转型  父类类型强制转为子类

代码:

  Animal a = new Dog();
//自动转型,也称向上转型,创建的Dog对象转换成Animal
 
  Cat  cat = (Cat)new Animal();
//强制转型,也称向下转型,创建的Animal对象被强制转换成Cat类型

tips:引用类型数据之间的转换在形式上(语法)与基本类型数据转换一致,可以认为父类是容量较大的数据类型,子类为容量较小的数据类型。

缺点:父类类型不能调用子类特有的方法。

instanceof() 可以用来判断父类引用实际表示的对象是不是指定类型。

 final关键字


final :可以修饰类 属性 方法

    修饰类:该类不能被其它类继承

    修饰方法:修饰的方法不能被重写

    修饰属性: 修饰后的属性是常量,创建时需要对其赋值,赋值后之不能改变。

final属性赋值

     ● 在声明时同时赋值,往往与static一起使用。

     ● 声明时不赋值,必须在构造方法中逐一赋值。

     ● 总的原则:保证创建每一个对象的时候,final属性的值是确定的

public class FinalDemo {

    private int index;
    private static final double pai=3.14; //声明时赋值
    private final int level;        //声明时没有赋值,在无参构造中为level赋值,以保证创建对象时,此值是确定的
    public FinalDemo(){
        level=0;
    }
    public FinalDemo(int index){
        this.index=index;
        level=1;
    }
}

错误案例:下面代码在声明和构造方法红都没有赋值

面向对象语言的三大特征_第2张图片

对参数做final修饰。

• 在方法参数前面加final关键字,为了防止数据在方法体中被修改。

public void test(final int x){
//        x = 10;
    }

错误案例:参数被final修饰,方法体中改变值,IDE会报错

面向对象语言的三大特征_第3张图片

接口


  概念

   Java接口是一系列方法的声明,是一些方法特征的集合,一个接口只有方法的特征没有方法的实现,因此这些方法可以在不同的地方被不同的类实现,而这些实现可以具有不同的行为(功能)

  通俗理解: 接口是一个更彻底的、纯抽象的类,可以定义,属性以及抽象方法,和抽象类一样用于体系结构的顶层中,制定规范,设计功能。

 特点

●接口中的成员变量默认是静态常量(用final static 修饰)

●可以定义抽象方法(只有方法名,没有方法体)

●JDK8之后可以定义静态方法(可以有方法体),直接通过接口名调用。

                  还可以定义默认方法(可以有方法体),通过子类调用

●一个接口可以继承多个接口,一个类可以实现多个接口,一个类只能直接继承一个类

(这就是我们使用接口的主要原因,java不像C++可以实现多继承,接口可以解决这个问题)

接口的定义和使用

接口的定义:使用 interface 关键字用来声明一个接口。

[访问修饰符] interface 接口名称 [extends 其他的接口名1,….其他的接口名n]{ // 声明常量 抽象方法 静态方法 默认方法

} 接口的使用:类使用implements关键字实现接口。在类声明中,Implements关键字放在class声明后面。 [访问修饰符] class 类名 implements 接口名1,接口名2……{ } 结合继承: [访问修饰符] class 类名 extends 父类名 implements 接口名1,接口名2……{}

接口的特性

  • 接口是隐式抽象的,当声明一个接口的时候,不必使用abstract关键字

  • 接口中方法可以是抽象的,静态的,默认的

  • 接口中声明的属性默认为 public static final 的

  • 接口不是被类继承了,而是要被类实现 接口不能实例化对象,无构造方法 一个类可以实现多个接口 与继承关系类似,接口与实现类之间存在多态性

  • 一个接口能继承其它多个接口 当类实现接口的时候,类要实现接口中所有的抽象方法。否则,类必须声明为抽象的类


    抽象类与接口的区别

    成员变量的区别

    抽象类中的成员变量可以是常量,也可以是变量,而接口的成员变量默认被 public static final修饰。

    构造方法的区别

    抽象类只是比较抽象的类,但归根结底还是一个类,所以抽象类有构造方法,而接口不是类,所以没有构造方法。

    成员方法的区别

    抽象类的成员方法可以定义抽象的,也可以定义非抽象的;接口在JDK1.7之前只能定义抽象的方法,JDK1.8后可以定义默认方法和静态方法。

    类与接口的关系区别

    类可以继承类,但一个类只能直接继承一个类,可以间接实现多层继承;接口是用来实现的,一个类可以同时实现多个接口。接口与接口的关系与类相似,也是继承关系,一个接口只能直接继承一个接口,也可以实现多层继承。

你可能感兴趣的:(笔试笔记,java)