Java面向对象三大特性

时间  2019-12-13
标签 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();

 

具体步骤：ide

  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 的属性和方法。this

继承应该遵循里氏替换原则，子类对象必须可以替换掉全部父类对象。

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

 

 

免费Java高级资料须要本身领取，涵盖了Java、Redis、MongoDB、MySQL、Zookeeper、Spring Cloud、Dubbo高并发分布式等教程，一共30G。
传送门：
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程