专栏首页Java程序猿部落Java面向对象三大特性
原创

Java面向对象三大特性

封装

1. 封装概述

利用抽象数据类型将数据和基于数据的操作封装在一起,使其构成一个不可分割的独立实体。 数据被保护在抽象数据类型的内部,尽可能地隐藏内部的细节, 只保留一些对外接口使之与外部发生联系。用户无需知道对象内部的细节, 但可以通过对象对外提供的接口来访问该对象。

2. 优点

  • 减少耦合:可以独立地开发、测试、优化、使用、理解和修改
  • 减轻维护的负担:可以更容易被程序员理解,并且在调试的时候可以不影响其他模块
  • 有效地调节性能:可以通过剖析确定哪些模块影响了系统的性能
  • 提高软件的可重用性
  • 降低了构建大型系统的风险:即使整个系统不可用,但是这些独立的模块却有可能是可用的

3. 成员变量和局部变量的区别

注意:局部变量名可以和成员变量名一样,在方法中使用的时候,采用就近原则。

4. 类的初始化过程

以Student类为例:

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

具体步骤:

  1. 加载Student.class文件进内存
  2. 栈内存为s开辟空间
  3. 堆内存为学生对象开辟空间
  4. 对学生成员变量进行默认初始化
  5. 对学生成员变量进行显示初始化
  6. 通过构造方法对学生对象的成员赋值
  7. 学生成员对象初始化完毕,将对象地址赋值给s变量。

封装:一个标准的手机类的代码及测试 手机类

public class SmartPhone {
    private String brand;
    private double price;
    private String color;

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public void call(String name){
        System.out.println("打电话给"+name);
    }

    public void sendMessage(String name){
        System.out.println("给"+name+"发短信");
    }

    public void playGame(){
        System.out.println("玩游戏");
    }
}

手机测试类1

public class SmartPhoneDemo {
    public static void main(String[] args) {
        SmartPhone sp=new SmartPhone();
        sp.setBrand("IPhone");
        sp.setPrice(6666);
        sp.setColor("白色");

        System.out.println("使用"+sp.getBrand()+"牌、售价为"+sp.getPrice()+"元的"
                +sp.getColor()+"的手机");
        sp.call("Jobs");
        sp.sendMessage("Kuke");
        sp.playGame();
    }
}

一个手机对象的内存简图:

手机测试类2

public class SmartPhoneDemo2 {
    public static void main(String[] args) {
        SmartPhone sp=new SmartPhone();
        sp.setBrand("IPhone");
        sp.setPrice(6666);
        sp.setColor("白色");

        System.out.println("使用"+sp.getBrand()+"牌、售价为"+sp.getPrice()+"元的"
                +sp.getColor()+"的手机");
        sp.call("Jobs");
        sp.sendMessage("Kuke");
        sp.playGame();

        SmartPhone sp2=new SmartPhone();
        sp2.setBrand("小米");
        sp2.setPrice(1000);
        sp2.setColor("黑色");

        SmartPhone sp3=sp;
        sp.setPrice(3555);
        System.out.println("使用"+sp.getBrand()+"牌、售价为"+sp.getPrice()+"元的"
                +sp.getColor()+"的手机");
    }
}

多个手机对象的内存简图:

5. 静态变量和成员变量的区别

6. 代码块

  • 静态代码块:在类加载的时候就执行,且执行一次。一般用于对对象进行初始化。
  • 构造代码块:每次调用构造方法都执行且在构造方法之前执行。一般是对类进行初始化。

执行顺序:

静态代码块---构造代码块---构造方法

public class CodeBlock {
    //构造方法
    CodeBlock(){
        int a=10;
        System.out.println(a);
    }

    //构造代码块
    {
        int a=100;
        System.out.println(a);
    }

    //静态代码块
    static {
        int a=1000;
        System.out.println(a);
    }

    public static void main(String[] args) {
        CodeBlock codeBlock=new CodeBlock();
    }
}

输出结果:

1000
100
10

继承

1. 继承概述

继承实现了 IS-A 关系,例如 Cat 和 Animal 就是一种 IS-A 关系,因此 Cat 可以继承自 Animal,从而获得 Animal 非 private 的属性和方法。

继承应该遵循里氏替换原则,子类对象必须能够替换掉所有父类对象。

Cat 可以当做 Animal 来使用,也就是说可以使用 Animal 引用 Cat 对象。父类引用指向子类对象称为 向上转型

Animal animal = new Cat();

2. 优点

  • 提高了代码的复用性
  • 提高了代码的维护性
  • 在类与之间产生了关系,是多态的前提

3. Java中继承特点

  • Java只支持单继承,不支持多继承
  • Java支持多层继承

4. Java中继承注意事项

  • 子类只能只能继承父类所有非私有成员(成员方法和成员变量)
  • 子类不能继承父类的构造方法,但是可以通过super关键在去访问父类构造方法
  • 不要为了部分功能而去继承
  • 继承中类之间体现的是“is a”的关系。

5. 继承中成员变量的关系

  • 子类中成员变量和父类中成员变量名称不同。
  • 子类中成员变量和父类中成员变量名称相同。

在子类方法中的查找顺序:

在子类方法的局部范围找,有就使用

在子类的成员范围找,有就使用

父类的成员范围找,有就使用

如果还找不到,就报错

6. 继承中构造方法的关系

  1. 子类中所有的构造方法默认会都会访问父类中空参数的构造方法

原因:因为子类会继承父类中的数据,可能还会使用父类的数据。所以,子类初始化之前, 一定要完成父类数据的初始化。

  1. 每一个子类的构造方法第一条语句默认是:super();
  2. 如果父类中没有无参构造方法,该怎么办呢?

方式一:子类通过super去显示调用父类其他的带参的构造方法

方式二:子类通过this去调用本类的其他构造方法 (子类一定要有一个去访问父类的构造方法,否则父类数据就没有初始化)

/**
* 1. 子类中所有的构造方法默认会都会访问父类中空参数的构造方法
* 2. 每一个子类的构造方法第一条语句默认是:super()
*/
class Father{
    public Father() {
        System.out.println("Father的无参构造函数");
    }
}

class Son extends Father{
    public Son() {
        //super();
        System.out.println("Son的无参构造函数");
    }
    public Son(String name) {
        //super();
        System.out.println("Son的带参构造函数");
    }
}

public class InheritanceDemo {
    public static void main(String[] args) {
        //使用无参构造函数初始化
        Son son=new Son();
        System.out.println("===========");
        //使用带参构造函数初始化
        Son son2=new Son("林青霞");
    }
}

输出结果:

Father的无参构造函数
Son的无参构造函数
===========
Father的无参构造函数
Son的带参构造函数
/**
 * 3. 如果父类中没有无参构造方法,该怎么办呢?

 方式一:子类通过super去显示调用父类其他的带参的构造方法

 方式二:子类通过this去调用本类的其他构造方法
 (子类一定要有一个去访问父类的构造方法,否则父类数据就没有初始化)
 */
class Parent{
    public Parent(String name){
        System.out.println("Parent的带参构造函数");
    }
}

class Child extends Parent{
    public Child() {
        //子类通过super去显示调用父类其他的带参的构造方法
        super("林青霞");
        System.out.println("Child的无参构造函数");
    }
    public Child(String name) {
        //方式一:子类通过super去显示调用父类其他的带参的构造方法
        //super(name);
        //方式二:子类通过this去调用本类的其他构造方法
        this();//嗲用Child()的无参构造函数
        System.out.println("Child的带参构造函数");
    }
}

public class InheritanceDemo2 {
    public static void main(String[] args) {
        Child c = new Child();
        System.out.println("==============");
        Child c2 = new Child("林青霞");
    }
}

输出结果:

Parent的带参构造函数
Child的无参构造函数
==============
Parent的带参构造函数
Child的无参构造函数
Child的带参构造函数

7.类中成员变量初始化

一个类的成员变量的初始化:

  1. 默认初始化
  2. 显式初始化
  3. 构造方法初始化

子类的初始化(分层初始化)

  • 先进行父类的初始化再进行子类的初始化
class X{
    Y b=new Y(); //显式初始化

    X(){
        System.out.println("X");
    }
}

class Y{
    Y(){
        System.out.println("Y");
    }
}

public class Z extends X{
    Y y=new Y();

    public Z() {
        super();//子类的初始化(分层初始化):先进行父类的初始化,然后再进行子类的初始化。
        System.out.println("Z");
    }

    public static void main(String[] args) {
        new Z();
    }
}

输出结果:

Y
X
Y
Z

7. 继承中成员方法的关系

重写(Override):子类和父类中出现了一模一样的方法声明

注意:

  1. 父类中私有成员方法不能被重写(因为父类中私有成员方法不能被继承)
  2. 子类重写父类中方法时,访问权限不能更低(最好一致)
  3. 父类是静态方法时,子类也必须通过静态方法进行重写。
  4. 子类和父类的声明最好一模一样。

8. final关键字

final关键字是最终的意思,可以修饰类,修饰变量,修饰成员方法

  • 修饰类:不能被继承
  • 修饰变量:变量就变成了常量,只能被赋值一次
  • 修饰方法:方法不能被重写

注意:

  1. final修饰局部变量

在方法内部,该变量不可以被改变

在方法声明上,分为基本类型和引用类型的情况

(1)基本类型:是值不能变

(2)引用类型:是地址不能变,但是该对象的堆内存中的值是可以改变的

  1. final修饰变量的初始化时机

在对象构造完毕前即可(非静态常量),被final修饰的变量只能赋值一次。

继承:一个标准的动物类、猫类、狗类的代码及测试 动物类

class Animal{
    private String name;
    private int age;
    private String color;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public void eat(){
        System.out.print("吃什么东西?");
    }
}

猫类

class Cat extends Animal{
    @Override
    public void eat() {
        super.eat();
        System.out.println("猫粮");
    }

    public void play(){
        System.out.println("小猫在玩耍");
    }
}

狗类

class Dog extends Animal{
    @Override
    public void eat() {
        super.eat();
        System.out.println("狗粮");
    }

    public void bark(){
        System.out.println("小狗汪汪叫");
    }
}

测试

public class AnimalDemo {
    public static void main(String[] args) {
        Dog dog=new Dog();
        dog.setName("旺财");
        dog.setAge(12);
        dog.setColor("黄色");
        System.out.println(dog.getName()+"\t"+dog.getAge()+"\t"+dog.getColor());
        dog.eat();
        dog.bark();

        Cat cat=new Cat();
        cat.setName("汤姆");
        cat.setAge(12);
        cat.setColor("蓝色");
        System.out.println(cat.getName()+"\t"+cat.getAge()+"\t"+cat.getColor());
        cat.eat();
        cat.play();
    }
}

多态

1. 多态概论

某一个事物,在不同时刻表现出来的不同状态。 具体来讲,就是调用同一方法,会执行不同的功能。

实际生活:水在不同时刻的状态。

2. 多态分类

多态分为编译时多态和运行时多态:

  • 编译时多态主要指方法的重载
  • 运行时多态指程序中定义的对象引用所指向的具体类型在运行期间才确定

3. 运行时多态有三个条件

  • 继承
  • 覆盖(重写)
  • 向上转型

4. 多态的好处和弊端

好处

提高了代码的维护性(由继承保证)

提高了程序的扩展性(由多态保证)

弊端

不能访问子类特有功能(特有方法)

如何访问子类中的特有功能?

  • 方法一:将父类的引用强制转换为子类的引用,即向下转型
  • 方法二:创建子类对象调用方法(可以,但是不合理,并且占内存)
/**
* 对象间的转型问题:
    向上转型:
        Parent f = new Child();
    向下转型:
        Child z = (Child)f; //要求该f必须是能够转换为Zi的。(父到子)
 */
class Parent {
    public void show() {
        System.out.println("show fu");
    }
}

class Child extends Parent {
    public void show() {
        System.out.println("show zi");
    }

    public void method() {
        System.out.println("method zi");
    }

}

public class PolymorphismDemo {
    public static void main(String[] args) {
         Parent fu=new Child();
        fu.show();
        //fu.method();//不能访问子类特有功能(特有方法)

        Child zi=(Child)fu; //向下转型
        zi.show();
        zi.method();
    }
}

输出结果:

show zi
show zi
method zi
class Animal {
    public void eat(){}
}

class Dog extends Animal {
    public void eat() {}

    public void lookDoor() {

    }
}

class Cat extends Animal {
    public void eat() {

    }

    public void playGame() {

    }
}

public class PolymorphismDemo3 {
    public static void main(String[] args) {
        //内存中的是狗
        Animal a = new Dog();
        Dog d = (Dog)a;

        //内存中是猫
        a = new Cat();
        Cat c = (Cat)a;

        //内存中是猫
        Dog dd = (Dog)a; //ClassCastException
    }
}

多态中对象内存图

5. 多态中的一些问题

/**
 * 多态中的成员访问特点:
     A:成员变量
        编译看左边,运行看左边。
    B:构造方法
         创建子类对象的时候,访问父类的构造方法,对父类的数据进行初始化。
    C:成员方法
        编译看左边,运行看右边。( 由于成员方法存在方法重写,所以它运行看右边。)
    D:静态方法
        编译看左边,运行看左边。(静态和类相关,算不上重写,所以,访问还是左边的)
 */
class Fu{
    public int num=100;

    public void show(){
        System.out.println("show function");
    }

    public static void function(){
        System.out.println("function Fu");
    }
}

class Zi extends Fu {
    public int num = 1000;
    public int num2 = 200;

    @Override
    public void show() {
        System.out.println("show Zi");
    }

    public void method() {
        System.out.println("method zi");
    }

    public static void function() {
        System.out.println("function Zi");
    }
}

public class PolymorphismDemo2 {
    public static void main(String[] args) {
        Fu f = new Zi();
        System.out.println(f.num);

        //System.out.println(f.num2);
        f.show();
        //找不到符号
        //f.method();
        f.function();
    }
}

输出结果:

100
show Zi
function Fu

原创声明,本文系作者授权云+社区发表,未经许可,不得转载。

如有侵权,请联系 yunjia_community@tencent.com 删除。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • Java内功心法,行为型设计模式

    使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系。 将这些对象连成一条链,并沿着这条链发送该请求,直到有一个对象处理它为止。

    李红
  • Java内功心法,行为型设计模式

    使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系。 将这些对象连成一条链,并沿着这条链发送该请求,直到有一个对象处理它为止。

    李红
  • Java内功心法,创建型设计模式包括哪些

    私有构造函数保证了不能通过构造函数来创建对象实例,只能通过公有静态函数返回唯一的私有静态变量。

    李红
  • SpringAOP

    动态代理分两种 JDK动态代理:只能对实现了接口的类产生代理 Cglib动态代理:第三方代理技术,对没有实现接口的类产生代理对象,生成子类对象,可以动态添加类的...

    用户3112896
  • Java设计模式(四)Builder建造者模式

    一、场景描述 建造者模式同工厂模式、抽象工厂模式一样,用于创建继承类对象。 工厂模式:http://www.cnblogs.com/mahongbiao/p/8...

    用户1637609
  • 浅谈.Net反射 11

    浅谈.Net反射系列基本来到了尾声,本文主要从.Net Framework的源码角度去分析:

    小蜜蜂
  • 模板模式

    模板模式,一个抽象类公开定义了执行它的方法的方式/模板、它的子类可以按需要重写方法实现,但调用将以抽象类中的定义的方式进行,属于行为型模式。

  • 异常中要了解的Throwable类中的几个方法

    *   public String getMessage()   获取异常的信息,返回的是字符串

    黑泽君
  • Android编程设计模式之中介者模式详解

    本文实例讲述了Android编程设计模式之中介者模式。分享给大家供大家参考,具体如下:

    砸漏
  • 任天堂:VR远未普及 成为主流为时尚早

    当每一家大型技术公司都想在虚拟现实中插一脚的时候,还有一位游戏巨头却坚持认为,虚拟现实距离成为主流还早得很。Facebook、谷歌、HTC、索尼、微软以及其他公...

    李海彬

扫码关注云+社区

领取腾讯云代金券