关键词：

面向对象特征

面向对象三大特征: 集成, 封装, 多态

继承

继承: - 子类可以从父类继承属性和方法
- 对外公开某些属性和方法

要点(eclipse中Ctrl+T查看继承结构)

1.父类也称超类, 基类, 派生类
2.Java中只有单继承, 没有C++那种多继承
3.接口有多继承
4.子类继承父类, 可以得到父类的全部属性和方法(除了构造方法), 但不一定可以直接访问(例如父类中的私有属性和方法) 5.如果定义一个类时, 没有调用extends, 则它的父类是java.lang.object

Object类是所有Java类的根基类, 也就意味着所有的Java对象都有object类的属性和方法

关键字super

super是直接父类对象的引用, 可以通过super来访问父类中被子类覆盖的方法或属性

属性/方法查找顺序(如变量h)

1.查找当前类中有没有属性h
2.依次上溯每个类的父类, 查看每个父类中有没有j, 直到object
3.如果没有找到, 则出现编译错误
4.上述步骤中, 只要找到变量h, 则这个过程终止

构造方法调用顺序

构造方法第一句总是super(...)来调用父类对应的构造方法. 所以流程是先向上追溯到object, 然后再依次向下执行类的初始化和构造方法, 直到当前子类为止, 同静态初始化块一样, 先把静态初始化全部执行(父类直至object和子类)完后, 再执行构造方法

封装

封装作用 - 对外隐藏某些属性和方法
- 对外公开某些属性和方法

修饰符	同一个类	同一个包	不同包的子类	所有类
private	*
defualt	*	*
proteced	*	*	*
public	*	*	*	*

成员(成员变量或成员方法)访问权限共四种:

private
　　只能被这个类本身访问
default
　　可以被这个类本身访问
　　可以被同一个包中的类访问
protected
　　可以被这个类分数访问
　　可以被同一个包中的所有其他类访问
　　被它的子类(同一个包以及不同包的子类)访问
public
　　可以被该项目的所有包中的所有类访问

类的访问权限共两种:

public
　　可以被同一项目中所有的类访问(必须与文件名同名)
default
　　可以被同一个包的类访问

封装要点:

类的属性的处理
　　一般使用private访问权限
　　提供相应的get/set方法来访问相关属性, 这些方法通常用public修饰, 以提供对属性的赋值与读取操作(boolean变量的get方法是以is开头)
一些只用于本类的辅助性方法可以用private修饰
希望其他类调用的方法用public修饰

重写

子类通过重写父类的方法, 可以用自身的行为替换父类的行为

重写的三个要点:

• "==" :方法名, 形参列表, 返回值类型相同
• "<=" : 返回值类型和声明异常类型, 子类小于等于父类
• ">=" : 访问权限, 子类大于等于父类. 重写的方法不能使用比被重写方法更严格的访问权限

public class TestOverride {
    public static void main(String[] args) {
        Vehicle v1 = new Vehicle();
        Vehicle v2 = new Horse();
        Vehicle v3 = new Plane();

        v1.run();
        v2.run();
        v3.run();

        v1.stop();
        v2.stop();
        v3.stop();
    }
}

class Vehicle {
    public void run() {
        System.out.println("跑.....");
    }
    public void stop() {
        System.out.println("停止不动");
    }
}

class Horse extends Vehicle {
    public void run() {
        System.out.println("嘚嘚......");
    }
}

class Plane extends Vehicle {
    public void run() {
        System.out.println("咻......");
    }
    public void stop() {
        System.out.println("根本停不下来");
        super.stop();       // 通过super调用父类Vehicle中被覆盖的stop函数
    }
}

/*执行结果
跑.....
嘚嘚......
咻......
停止不动
停止不动
根本停不下来
停止不动
*/

多态

多态: 指同一个方法调用, 由于对象的不同, 可能会有不同的行为, 适应多种变化, 使得代码变得更加通用
属性没有多态

引用变量的两种类型:

• 编译时类型(模糊一点, 一般是一个父类)
  　　由声明时类型决定
• 运行时类型(运行时, 具体是哪个子类就是哪个子类)
  　　由实际对应的对象类型决定

多态要点:

1.多态是方法的多态, 不是属性的多态(多态与属性无关)
2.多态的存在要有3个必要条件: 继承, 方法重写, 父类引用指向子类对象
3.父类引用指向子类对象后, 用该父类引用调用子类重写的方法, 此时实现多态

对象的转型

父类引用指向子类对象, 称这个过程为向上转型, 属于自动类型转换, 向上转型后的父类引用变量只能调用它编译类型的方法, 不能调用它运行时的方法. 这时需要进行类型的强制转换, 称之为向下转型, 在向下转型过程中, 必须将引用变量转换成真实的子类类型(运行时类型), 否则会出现转换异常ClassCastException

子类转换为父类: 自动转换 - 上转型对象不能操作子类新增的成员变量和方法
- 上转型对象可以操作子类继承或重写的成员变量和方法 - 如果子类重写了父类的某个方法, 上转型对象调用该方法时, 是调用的重写方法

父类转换为子类: 强制转换

public class TestPolym {
    public static void main(String[] args) {
        Animal animal = new Dog();      // 向上类型转换

        // 属性没有多态！！！
        System.out.println(animal.age); // 属性调用时, 仍然是基类属性, 属性没有多态
        animal.shout();         // 调用Dog类中的shout函数
        animalCry(animal);

        // 传的具体是哪一个类就调用哪一个类的方法, 大大提高了程序的可扩展性
        // 如果没有多态, 这里需要写很多重载方法, 如果增加一种动物, 就需要重载一种动物的叫法, 非常麻烦
        animalCry(new Dog());

        // 有了多态后, 只需要增加这个类继承Animal基类就可以了
        animalCry(new Dog());

        // 编写程序时, 如果想调用运行时类的方法, 只能进行类型转换, 不然通不过编译器检查
        Dog dog = (Dog) animal;
        dog.gnawBone(); 

        System.out.println(dog instanceof Animal);
        System.out.println(animal instanceof Cat);
        System.out.println(animal instanceof Dog);

        Dog d = new Dog();
        animalCry(d);

    }

    static void animalCry(Animal a) 
    {
        a.shout();
    }
    /***********没有多态时需重写下面两个重载方法**************
    static void animalCry(Dog a) 
    {
        a.shout();
    }
    static void animalCry(Cat a) 
    {
        a.shout();
    }
    ***********************************************************/
}

class Animal {
    int age = 10;

    public void shout() {
        System.out.println("叫了一声");
    }
}

class Dog extends Animal {
    int age = 28;

    public void shout() {
        System.out.println("旺旺");
    }

    public void gnawBone() {
        System.out.println("在啃骨头");
    }
}

class Cat extends Animal {
    int age = 18;

    public void shout() {
        System.out.println("喵喵");
    }
}
/*
10
旺旺
旺旺
旺旺
旺旺
在啃骨头
*/

抽象类

抽象类是一种模板, 为所有子类提供一个通用模板, 子类可以在这个模板基础上进行扩展
通过抽象类可以避免子类设计的随意性, 这样就可以做到严格限制子类的设计, 使子类之间更加通用

要点:

抽象方法和抽象类都必须使用abstract来修饰
抽象方法没有方法体, 只需要声明不需要实现

抽象方法的类只能定义抽象类
相反, 抽象类里的方法不一定全是抽象方法, 也可以没有抽象方法

抽象类可以包含属性, 方法, 构造方法
抽象类不能实例化, 及不能用new来实例化抽象类, 只能用来被子类调用
抽象类只能用来继承
抽象方法必须被子类实现, 抽象类的子类必须覆盖所有的抽象方法才能被实例化, 否则还是抽象类

接口

接口与类的区别:

接口是比"抽象类"还抽象的"抽象类", 可以更加规范的对子类进行约束. 全面的专业的石祥路: 规范和具体实现的分离 接口就是规范, 定义的是一组规则, 体现了现实世界中"如果能..., 则必须..."的意思 接口的本质是契约, 定制好后大家都需遵守 项目的具体需求是多变的, 必须以不变应万变才能从容开发, 此处的"不变"就是"规范"

接口相关规则:

接口中所有方法都是抽象的
即使没有显式的将接口中的成员用public标示, 也是public访问类型
接口中变量默认用public static final标示, 所有接口中定义的变量就是全局静态常量
接口中方法默认用public abstract表示

可以定义一个新接口, 用extends区继承一个已有的接口
可以定义一个类, 用implements去实现一个接口中所有方法
可以定义一个抽象类, 用implements去实现一个接口中部分方法

格式: [访问修饰符] interface 接口名 [extends 父接口1, 父接口2, ...] { 常量定义 // 总是: public static final 方法定义 // 总是: public abstract }

接口的实现

子类通过implements来实现接口中的规范
接口不能创建实例, 但是可以用于声明引用变量类型
一个类实现了接口, 必须事项接口中所有的方法, 并且这些方法只能是p ublic
Java的类只支持单继承, 接口支持多继承

内部类

内部类: 将一个类定义置入另一个类定义中

类中定义的内部类特点 内部类作为外部类的成员, 可以直接访问外部类的成员(包括private成员), 反之则不行
内部类作为外部类成员, 可以声明为private, 默认, protected, public
内部类成员只有在内部类的方位之内是有效的
用内部类定义在外部类中不可访问的属性. 这样就在外部类中实现了比外部类private还要小的访问权限
编译后生成两个类: OuterClass.class和OuterClass$InnerClass.class

内部类分类有: 成员内部类, 静态内部类, 方法内部类, 匿名内部类

匿名内部类:

可以实现一个接口, 或者继承一个父类 只能实现一个借口
适合创建那种只需要一次使用的类, 不能重复使用. 比较常见的是在图形界面GUI里用得到 匿名内部类要使用外部类的局部变量, 必须使用final修饰该局部变量

java面向对象特征

面向对象特征面向对象三大特征:集成,封装,多态继承继承:-子类可以从父类继承属性和方法-对外公开某些属性和方法要点(eclipse中Ctrl+T查看继承结构)1.父类也称超类,基类,派生类2.Java中只有单继承,没有C++那种多继承3.接口有多继... 查看详情

面向对象的特征有哪些？

Java语言的特点有哪些？1.简单性：2.面向对象3.与平台无关4.安全性和健壮性（鲁棒性）5.多线程  面向对象的特征有哪些？08年以前面向对象的特征：思维方式的特征，是三大特征：3大特征1.封装2.继承3.多态Java是第一个纯... 查看详情

5.1-全栈java笔记:面向对象的特征继承|上

JAVA面向对象进阶本章重点针对面向对象的三大特征：继承、封装、多态，进行详细的讲解。很多概念对于初学者来说，更多的是先进行语法性质的了解，不要期望，通过本章学习就“搞透面向对象”。本章只是面向对象的起点... 查看详情

java大厂面试必刷题day1：何为面向对象编程的思想？面向对象三大特征是什么？

文章目录前言一、何为面向对象编程的思想？二、面向对象的三大特征2.1、封装关系2.2、继承关系2.3、多态关系总结前言从本文我们将开始《Java大厂面试必刷题》系列的更新，Java面试必刷题Day1：何为面向对象编程的思想？面向... 查看详情

java大厂面试必刷题day1：何为面向对象编程的思想？面向对象三大特征是什么？

文章目录前言一、何为面向对象编程的思想？二、面向对象的三大特征2.1、封装关系2.2、继承关系2.3、多态关系总结前言从本文我们将开始《Java大厂面试必刷题》系列的更新，Java面试必刷题Day1：何为面向对象编程的思想？面向... 查看详情

java基础之面向对象的特征。

首先需要知道类和对象是什么？　　维基百科定义类为： anextensibleprogram-code-templateforcreating objects,providinginitialvaluesforstate(membervariables)andimplementationsofbehavior(memberfunctionsor methods)，即能够 查看详情

java面向对象的三大特征

Java面向对象的三大特征：封装、继承、多态封装和继承几乎都是为多态而准备的一、     封装首先，属性能够描述事物的特征，方法能够描述事物的动作。封装就是把同一类事物的共性（包括属性和方法）归... 查看详情

java面向对象三大特征之继承和多态(代码片段)

...转型多态代码案例总结前言  上一篇博客我们介绍了Java面向对象思想以及三大特征之一的封装。本文将介绍面向对象三大特征的剩下两个特征——继承和多态，我个人认为继承和多态是三个特征中比较重要且理解起来稍有... 查看详情

java面向对象的三大特征

面向对象三大特征：封装性继承性多态性1.封装性 所谓封装，也就是把客观事物封装成抽象的类，并且类可以把自己的属性和方法只给特定的对象或其他类进行访问，即使用不同的访问统治权限使类被不同的对象访问，类中... 查看详情

java面向对象的三大特征

面向对象主要由三大特性：　　封装　　继承　　多态 一、封装1、封装的概念　　封装性是面向对象编程的核心思想　　指的就是将描述某种实体的数据和基于这些数的操作集合到一起，形成一个封装体　　封装的思想保... 查看详情

java面向对象编程思想

1、面向对象编程是什么  面向对象编程(ObjectOrientedProgramming，故常称OOP)并非Java独有，而是一种编程的思想，Java、C++、Python均有对其实现。其本质是以建立模型体现出来的抽象思维过程和面向对象的方法。模型是用来反映... 查看详情

面向过程面向对象及面向对象的三大特征

面向过程：procedureorientedprogrammingPOP面向对象：objectorientedprogrammingOOP了解面向对象，我们来了解一下面向对象中的核心概念类和对象类：类是对某一类事物的描述，是抽象的、概念上的定义。对象：现实世界中客观存在的事务就... 查看详情

java面向对象三大基本特征(代码片段)

...意事项：4.多态4.1多态思想4.2 多态中的转型如何理解面向对象？简单的说就是把事物和操作事物的方法汇集到一起，形成一个相互依赖的整体。下面我们来了解面向对象的基础知识1.类和对象1.1概念 查看详情

java面向对象特征

(1).抽象：把需要用到的重要的东西抽出来，不重要的东西忽略掉。 (2).继承：子类继承父类的非私有成员，重用具有相同的属性，当父类方法满足不了时，重写父类不具有的特征属性，方法结构保持与父类一致。（既能重用... 查看详情

5.2-全栈java笔记:面向对象的特征继承|下

上节我们聊到「Java面向对象的特征：继承」这节我们继续聊一下继承的应用。Object类Object类基本特性Object类是所有Java类的根基类，也就意味着所有的JAVA对象都拥有Object类的属性和方法。如果在类的声明中未使用extends关键字指... 查看详情

java面向对象常见概念

面向对象的特征三大特征packagecom.cloud.day2;/*面向对象三大特征：  1.封装  2.继承  3 多态。需求： 使用java类描述百合网的会员。问题：性别有问题？？根本原因：由于其他人可以直接操作sex属性。可... 查看详情

java面向对象的三大特征和五大原则

Java面向对象的三大特征封装封装(Encapsulation）是指属性私有化，根据需要提供setter和getter方法来访问属性。即隐藏具体属性和实现细节，仅对外开放接口，控制程序中属性的访问级别。封装目的：增强数据安全性，不能让其他用... 查看详情

谈面向对象的三大特征

　引：什么是面向对象？　面向对象，专注于由谁（哪个对象）来解决这个问题，而调用者无需关注对象实现的细节。　编程特点：出现了一个个的类，从类中拿到对象，通过对象直接解决问题。　应用：Java PHP c++ c#... 查看详情