javaSE——三大特性：封装、继承、多态

封装

制造厂家为了方便我们使用电视，把复杂的内部细节全部封装起来，只给我们暴露简单的接口，比如：电源开关。需要让用户知道的暴露出来，不需要让用户了解的全部隐藏起来。这就是封装。

专业的话来讲：我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。

封装（数据的隐藏）

通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

1、封装的步骤

使用private 修饰需要封装的成员变量。
提供一个公开的方法 或者 访问私有的属性

设置通过set方法，命名格式： set属性名（）; 属性的首字母要大写

访问通过get方法，命名格式： get属性名（）; 属性的首字母要大写

在类中一般不会把数据直接暴露在外部的,而使用private(私有)关键字把数据隐藏起来

【演示】

package com.kuang.oop;

public class Student {
    private String name;

    public void println() {
        System.out.println(this.name);
    }

}
public class Application {
    public static void main(String[] args) {
        // 创建一个对象
        Student s = new Student();

        // s.name = "tom";编译器报错，在类的外部不能直接访问类中的私有成员
        s.println();// 可以通过类的一个public方法作为接口间接访问name，但通常都是用get和set作为方法名的

    }
}

如果在类的外部需要访问这些私有属性,那么可以在类中提供对于的get和set方法,以便让用户在类的外部可以间接的访问到私有属性

示例

package com.kuang.oop;

public class Student {
    private String name;

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

    public String getName() {
        return this.name;
    }

}

public class Application {
    public static void main(String[] args) {
        // 创建一个对象
        Student s = new Student();

        s.setName("Tom");

        System.out.println(s.getName());

    }
}

2、作用和意义

提高程序的安全性，保护数据。
隐藏代码的实现细节
统一用户的调用接口
提高系统的可维护性
便于调用者调用。

良好的封装，便于修改内部代码，提高可维护性。

良好的封装，可进行数据完整性检测，保证数据的有效性。

3、方法重载

类中有多个方法,有着相同的方法名,但是方法的参数各不相同,这种情况被称为方法的重载。

体现方法调用的灵活性。

方法重载必须满足以下条件

方法名必须相同
参数列表必须不同(参数的类型、个数、顺序的不同)，但返回类型同不同不作数

public void test(Strig str){}
public void test(int a){}

public void test(Strig str,double d){}
public void test(Strig str){}

public void test(Strig str,double d){}
public void test(double d,Strig str){}

在java中,判断一个类中的俩个方法是否相同,主要参考俩个方面:方法名字和参数列表

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。

提高代码的复用性。子类是父类的扩展。

【注】JAVA中类只有单继承，没有多继承！接口可以多继承！

1、继承

继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。

public class student extends Person{
    
}

子类和父类之间,从意义上讲应该具有"is a"的关系.

student is a person
dog is a animal

类和类之间的继承是单继承——一个子类只能有一个父类

一个子类只能"直接"继承一个父类,就像是一个人只能有一个亲生父亲
一个父类可以被多子类继承,就像一个父亲可以有多个孩子
    
注:java中接口和接口之间,有可以继承,并且是多继承

父类中的属性和方法可以被子类继承

子类中继承了父类中的属性和方法后,在子类中能不能直接使用这些属性和方法：

和这些属性和方法原有的修饰符(public protected default private)相关的。

例如 :

父类中的属性和方法使用public修饰,在子类中继承后"可以直接"使用

父类中的属性和方法使用private修饰,在子类中继承后"不可以直接"使用

注：具体细则在修饰符部分详细说明

父类中的构造器是不能被子类继承的,但是子类的构造器中,会隐式的调用父类中的无参构造器(默认使用 super关键字)。

注:具体细节在super关键字部分详细说明

2、Object类

每一个类都是"直接" 或者 "间接"的继承了Object类.

从API文档中,可以看到任何一个类最上层的父类都是Object。(Object类本身除外)

【示例】

System.out.println(任何对象 instanceof Object);
//输出结果:true
//注:任何对象也包含数组对象

例如:
//编译后,Person类会默认继承Object
public class Person{}

//Student是间接的继承了Object
public class Student extends Person{}

在java中,任何一个对象都可以调用从Object中继承过来的方法。

例如:toString方法、equals方法、getClass方法等

注:Object类中的每一个方法之后都会使用到.

3、Super关键字

子类继承父类之后,

在子类中可以使用this来表示访问或调用子类中的属性或方法,
使用super就表示访问或调用父类中的属性和方法。

1、super的使用

【在子类中访问父类中的属性】

public class Person{
	protected String name = "zs";
}
public class Student extends Person{
    private String name = "lisi";
    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}

【调用父类中的方法】

package com.kuang.oop;

public class Person {
    public void print() {
        System.out.println("Person");
    }
}
//子类Student
public class Student extends Person {
    //private String name;

    public void print() {
        System.out.println("Student");
    }

    public void test() {
        print(); // 默认是this的方法
        this.print();
        super.print();//调用父类的print()
    }

}

public class Application {
    public static void main(String[] args) {
        // 创建一个对象
        Student s = new Student();

        s.test();

    }
}

【调用父类中的构造器】

public class Person{
    
}
public class Student extends Person{
    //编译通过,子类构造器中会隐式的调用父类的无参构造器
    //super();
    public Student(){
    }
}

例外：父类没有无参构造时发生的情况，但下面那种情况允许父类没有无参构造

public class Person{
    protected String name;
    public Person(String name){
    	this.name = name;
    }
}
public class Student extends Person{
    //编译报错,子类构造器中会隐式的调用父类的无参构造器,但是父类中没有无参构造器
    //super();
    public Student(){
    }
}

【但是子无参构造器可以显式的调用父类的有参构造器】

package com.kuang.oop;

public class Person {
    protected String name;
	//父类没有无参构造
    public Person(String name) {
        this.name = name;
    }
}

public class Student extends Person {
	//子类的无参构造
    public Student() {
        //显式调用父类的有参构造器，没有报错
        super("tom");
    }

}

super和this的区别

【super使用的注意的地方】

用super调用父类构造方法，必须是构造方法中的第一个语句。
super只能出现在子类的方法或者构造方法中。
super（）和 this （）不能够同时调用构造方法。（因为this也是在构造方法的第一个语句）【即不能同时出现在一个构造器中】

注：不管是显式还是隐式的父类的构造器,super语句一定要出现在子类构造器中第一行代码。所以this和 super不可能同时使用它们调用构造器的功能,因为它们都要出现在第一行代码位置。

【例子】

package com.kuang.oop;

public class Person {
    protected String name;

    public Person(String name) {
        this.name = name;
    }
}

public class Student extends Person {
	//编译报错,super调用构造器的语句不是第一行代码
    public Student() {
        System.out.println("Student");
        super("tom");
    }

}

【例子】

public class Person {
    protected String name;

    public Person(String name) {
        this.name = name;
    }
}

// 编译通过
public class Student extends Person {
    private int age;

    public Student() {
        this(20);
    }

    public Student(int age) {
        super("tom");
        this.age = age;
    }
}

4、方法重写

方法的重写【也不等同于子类对父类方法的重载】（override）

重写的语法

方法名必须相同

参数列表必须相同

子类的访问控制修饰符可以被扩大,但是不能被缩小： public< protected <default< private

抛出异常类型的范围可以被缩小,但是不能被扩大 ClassNotFoundException ---> Exception

返回类型可以相同,也可以不同,如果不同的话,子类重写后的方法返回类型必须是父类方法返回类型的子类型

例如：父类方法的返回类型是Person,子类重写后的返回类可以是Person也可以是Person的子类型

注：一般情况下,重写的方法会和父类中的方法的声明完全保持一致,只有方法的实现不同。(也就是大括号（函数体）中代码不一样)

方法重写只存在于子类和父类(包括直接父类和间接父类)之间。在同一个类中方法只能被重载，不能被重写.
静态方法不能重写（指就算能，也不能覆盖，真正的重写应当是覆盖）
1. 父类的静态方法不能被子类重写为非静态方法 //编译出错
2. 父类的非静态方法不能被子类重写为静态方法；//编译出错
3. 子类可以定义与父类的静态方法同名的静态方法(但是这个不是覆盖)

【静态方法“重写”，其实不算重写】

【非静态方法重写】

并且重写的方法必须为公有public

私有方法不能被子类重写，子类继承父类后,是不能直接访问父类中的私有方法的,那么就更谈不上重写了。

为什么要重写？

子类继承父类,继承了父类中的方法,但是父类中的方法并不一定能满足子类中的功能需要,所以子类中需要把方法进行重写。

总结

方法重写的时候，必须存在继承关系。

方法重写的时候，方法名和形式参数必须跟父类是一致的。

方法重写的时候，子类的权限修饰符必须要大于或者等于父类的权限修饰符。( private < protected < public，friendly < public )

方法重写的时候，子类的返回值类型必须小于或者等于父类的返回值类型。（也就是必须是该父类的任意子类型或者直接拿父类做返回值）

方法重写的时候，子类的异常类型要小于或者等于父类的异常类型。

多态

1、认识多态

主要是用来实现动态联编的，换句话说，就是程序的最终状态只有在 执行过程中才被决定而非在编译期间就决定了。

多态可以让我们不用关心某个对象到底是什么具体类型，就可以使用该对象的某些方法。

允许不同类的对象对同一消息做出响应。

即同一消息可以根据发送对象的不同而采用多种不同的行为方式。

相同类域的不同对象,调用相同的方法,执行结果是不同的

一个对象的实际类型是确定的 new Student()
可以指向对象的引用的类型有很多

例如：Student继承了Person类

Student s1 = new Student();
Person s2 = new Student();
Object s3 = new Student();
因为Person和Object都是Student的父类型
    注:一个对象的实际类型是确定的（Student()）,但是可以指向这个对象的引用的类型 却是可以是这对象实际类型的 任意父类型。

一个父类引用可以指向它的任何一个子类对象

例如：

Object o = new AnyClass();
Person p = null;//person是stu和tea的父类
p = new Student();
p = new Teacher();
p = new Person();

多态中的方法调用

public class Person{
	public void run(){}
}
public class Student extends Person{
}

调用到的run方法,是Student从Person继承过来的run方法
main:

Person p = new Student();
p.run();   
或者
Student s = new Student();
s.run();
效果一样


//重写方法以后
public class Person{
	public void run(){}
}
public class Student extends Person{
    public void run(){
    	//重写run方法
    }
}
//调用到的run方法,是Student中重写的run方法
main:
Person p = new Student();
p.run();//运行结果为重写方法中的内容

子类中独有方法的调用（新增一个子类自己的方法）

public class Person {
    public void run() {
    }
}

public class Student extends Person {
    public void test() {
    }
}


main:
Person p = new Student();
// 调用到继承的run方法
p.run();
// 编译报错,因为编译器检查变量p的类型是Person,但是在Person类中并没有发现test方法,所以编译报错.就是子类独有test，父类引用无法调用这个方法
p.test();

原理：编译看左边，运行不一定看右边。

编译看左边的意思：java 编译器在编译的时候会检测引用类型中含有指定的成员，如果没有就会报错。子类的成员是特有的，父类的没有的，所以他是找不到的。

子类引用和父类引用指向对象的区别

变量s能调用的方法是Student中有的方法(包括继承过来的),变量p能调用的方法是Person中有的方法(包括继承过来的)。

Object类型的变量o,能指向所有对象,它的引用范围最大,但是使用变量o能调用到的方法也是最少的,只能调用到Object中的声明的方法

2、重写、重载和多态的关系

重载是编译时多态

调用重载的方法,在编译期间就要确定调用的方法是谁,如果不能确定则编译报错

重写是运行时多态

调用重写的方法,在运行期间才能确定这个方法到底是哪个对象中的。这个取决于调用方法的引用,在运行期间所指向的对象是谁,这个引用指向哪个对象那么调用的就是哪个对象中的方法。(java中的方法调用, 是运行时动态和对象绑定的)

3、多态的注意事项！！！！（看下视频）

多态是方法的多态，属性没有多态性。
编写程序时，如果想调用运行时类型的方法，只能进行类型转换。不然通不过编译器的检查。但是如果两个没有关联的类进行强制转换，会报：ClassCastException。比如：本来是狗，我把它转成猫。就会报这个异常。

4、多态存在的条件（三者缺一不可）

有继承关系
子类重写父类方法
父类引用指向子类对象

以下三种类型的方法是没有办法表现出多态特性的（因为不能被重写）：

static方法，属于类的，而不是属于实例的

final方法，因为被final修饰的方法无法被子类重写

private方法和protected方法，前者是因为被private修饰的方法对子类不可见，后者是因为尽管被 protected修饰的方法可以被子类见到，也可以被子类重写，但是它是无法被外部所引用的，一个 不能被外部引用的方法，怎么能谈多态呢

5、方法绑定(method binding)

执行调用方法时，系统根据相关信息，能够执行内存地址中代表该方法的代码。分为静态绑定和动态绑定。

静态绑定：

在编译期完成，可以提高代码执行速度。

动态绑定：

通过对象调用的方法，采用动态绑定机制。这虽然让我们编程灵活，但是降低了代码的执行速度。这也是JAVA比C/C++速度慢的主要因素之一。

JAVA中除了final类、final方、static方法，所有方法都是JVM在运行期才进行动态绑定的。

注：多态：如果编译时类型和运行时类型不一致，就会造成多态。

6、instanceof和类型转换

instanceof 就是判断父子关系的语法（就是拿来举例子时的白话“is a”）

public class Person{
	public void run(){}
}
public class Student extends Person{
}
public class Teacher extends Person{
}

main:

//Object > String
//Object > Person > Teacher
//Object > Person > Student
Object o = new Student();
System.out.println(o instanceof Student);//true
System.out.println(o instanceof Person);//true
System.out.println(o instanceof Object);//true
System.out.println(o instanceof Teacher);//false
System.out.println(o instanceof String);//false
\---------------------------
Person o = new Student();
System.out.println(o instanceof Student);//true
System.out.println(o instanceof Person);//true
System.out.println(o instanceof Object);//true
System.out.println(o instanceof Teacher);//false
//编译报错
System.out.println(o instanceof String);
\---------------------------
Student o = new Student();
System.out.println(o instanceof Student);//true
System.out.println(o instanceof Person);//true
System.out.println(o instanceof Object);//true
//编译报错
System.out.println(o instanceof Teacher);//没有
//编译报错
System.out.println(o instanceof String);

【分析1】

System.out.println(x instanceof Y);

该代码能否编译通过,主要是看声明变量x的类型（声明类型就是看左边）和Y是否存在子父类的关系.有"子父类关"系就编译通过, 没有子父类关系就是编译报错.

之后学习到的接口类型和这个是有点区别的。

【分析2】

System.out.println(x instanceof Y);

输出结果是true还是false,主要是看变量x所指向的对象实际类型（实际类型看右边）是不是Y类型的"子类型或同类型".

类型转换

public class Person{
	public void run(){}
}
public class Student extends Person{
	public void go(){}
}
public class Teacher extends Person{
}

【为什么要类型转换】

// 编译报错,因为p声明的类型Person中没有go方法
Person p = new Student();p.go();
// 需要把变量p的类型进行转换
Person p = new Student();
Student s = (Student) p;
s.go();

或者
//注意这种形式前面必须要俩个小括号
((Student)p).go();

【类型转换中的问题】

//1编译通过 运行没问题
Object o = new Student();
Person p = (Person)o;

//2编译通过 运行没问题、
Object o = new Student();//o是一个指向子类的父类引用
Student s = (Student)o;//向下转型，强转

//3编译通过,运行报错
Object o = new Teacher();
Student s = (Student)o;

即: X x = (X)o;

运行是否报错,主要是变量o所指向的对象实际类型（看右边）,是不是X类型的子类型,如果不是则运行就会报错。（如3）

【总结】

父类引用可以指向子类对象，子类引用不能指向父类对象。

把子类对象直接赋给父类引用叫upcasting向上转型，向上转型不用强制转型。

如Father father = new Son();

把指向子类对象的父类引用赋给子类引用叫向下转型（downcasting），要强制转型。

如father就是一个指向子类对象的父类引用，把father赋给子类引用son 即Son son =（Son） father；其中father前面的（Son）必须添加，进行强制转换。

upcasting 会丢失子类特有的方法,但是子类overriding （重写）父类的方法，子类方法有效

向上转型的作用：减少重复代码；

父类为参数，调用时用子类作为参数，就是利用了向上转型。这样使代码变得简洁。体现了JAVA的抽象编程思想。

posted @ 2022-06-14 14:10 群青Bleu 阅读(41) 评论(0) 编辑收藏举报

刷新页面返回顶部

群青Bleu