Java的三大特性：封装、继承、多态

时间 2019-12-09

标签 java 三大特性封装继承栏目 Java 繁體版

原文原文链接

1、类的概念:java

类通常包括两个部分:属性（成员变量）和方法（成员方法）
方法组成部分:修饰符（可选）返回值类型（必须）方法名（必须）参数列表（可选）数组

package com.classTest.project;

public class ClassTest {
    //成员变量
    String name;
    int age;
    //成员方法
    public void count(){
        this.age+=1;
    }

}

2、定义方法的几点说明安全

一、返回值类型：基本数据类型(整型(int)、浮点型(float)、字符串类型(String)、字符型(char)等)、引用数据类型(数组、类、接口)模块化

例子:测试

①基本数据类型做为返回值类型:this

⑴整型(int)spa

⑵浮点型(float)code

⑶字符串类型(String)对象

⑷字符型(char)blog

package com.returntype.project;

public class BasicData {
    
    public static void main(String[] args) {
        
        BDMethod BdMethod=new BDMethod();
        int getInt=BdMethod.getInt();
        System.out.println("返回值为整型的返回的内容:"+getInt);
        float getFloat=BdMethod.getFloat();
        System.out.println("返回值为浮点型的返回的内容:"+getFloat);
        String getString=BdMethod.getString();
        System.out.println("返回值为字符串型的返回的内容:"+getString);
        char getChar=BdMethod.getChar();
        System.out.println("返回值为字符的返回的内容:"+getChar);
        
    }

}

package com.returntype.project;

public class BDMethod {
    public int getInt(){
        return  2;
    }
    
    public float getFloat(){
        return 3.2f;
    }
    
    public String getString(){
        return "返回值String类型";
    }
    
    public char getChar(){
        return 'a';
    }
}

②引用数据类型做为放回值类型:

⑴数组

⑵类

⑶接口

二、修饰符:访问级别(public、private、protect、default)

	同一类	同一包	不一样包的子类	不一样包的非子类
public	✔	✔	✔	✔
protect	✔	✔	✔
default	✔	✔
private	✔

三、参数列表:

实参:它是指方法在被调用时，参数列表所传入的参数

基本数据类型为实参时，直接以变量的形式传入

　　　引用数据类型为实参时，数组是把数组名传入，类是把对象名传入，接口通常不作为实参传入

例子:

sum(a,b);//这里的a和b是实参

形参:它是指方法在定义时，参数列表所写的参数

基本数据类型做为形参时，直接以变量的形式传入

引用数据类型做为形参时，以数组声明的方式或者以类声明引用变量的方式

例子:

void sum(int a,int b);//这里的a和b是形参

四、方法的注意事项:

一、方法中不能定义方法

//错误例子
public void sum(){
        void change();
    }

二、实参不能带数据类型

//错误例子
sum(String name,int age);

三、实参与形参要为同一类型(自动类型转换除外)
例如:void sum(String name,int age)
sum(username,userage)//name的类型必须是String,userage的类型必须是int

四、传参：
一、String类型变量，在没有给他赋值时，默认值null, int类型的变量默认为0，double类型的变量默认为0.0

二、局部变量和成员变量
局部变量（在方法中定义）
成员变量（在类中定义）

3、构成方法:

一、为何要用构造方法：
构造方法至关因而提供一个场所，为建立一个对象而提供的一个场所。

二、构造方法的注意事项:

　　①构造方法的名字跟类名同样

　　②无返回类型

　　③若是在类中没有定义构造方法，系统默认会创造一个无参数的构造方法，只要在类中定义本身的构造方法，系统便不会再创造参数的构造方法

三、带参数的构造方法:能够为成员变量初始化

getter and setter 的做用:

（1）安全性，里面参数不能随意修改；

（2）类提供给外面的接口；

四、方法的重载:
　　定义:在同一个类中，方法名相同，参数的个数或者类型不一样
　　判断方法是否是重载的依据:

①方法是否在同一个类中

②方法名是否相同

③方法的参数个数或者类型是否不一样

五、修改属性（成员变量的可见性）:

①经过访问修饰符设置访问修饰符；public private protected default
②public修饰的成员变量和方法:类、外部能够直接访问
③private修饰的成员变量和方法:类里面是能够直接访问，可是外部不可访问

六、static关键字的使用：
由static关键字修饰的成员变量和方法，他们属于类自己，他们分别叫静态成员变量或者静态成员方法
静态成员变量定义语法：
修饰符 static 关键字类型变量名
好比:public static int i=0；
如何使用:
一般采用类名+"."调用或者不推荐采用对象名+"."调用
语法:类名.静态成员变量或者类名.静态成员方法

静态成员方法语法:
修饰符static 返回类型方法名（参数列表）{
　　//方法体
}
引用静态成员如何使用:
一般采用类名+"."调用或者不推荐采用对象名+"."调用
语法:类名.静态变量或者类名.静态成员方法

注意事项:
①静态成员方法中，只能调用静态成员方法和静态变量，且静态变量不能用this引用

②不是有static关键字的修饰方法，称做为对象方法

③在对象方法中，能够用静态成员方法

package com.classTest.project;

public class ClassTest {
    int age;//不是由static关键字修饰的成员变量或成员方法，它们只属于对象才能够引用 static int num;//有static关键字修饰的成员方法或者成员变量，它们是属于类自己，不依赖于对象而存在，可是对象能够去引用它们，可是不推荐经过对象去引用，他们的引用方式:类名.成员变量(成员方法)
public void count(){

//两种的表达形式均可以
        this.age+=1; age+=1; } public void count1(){ //普通方法便可调用普通方法和调用静态方法，也能够调用成员变量和静态变量
        this.age+=1; num+=1; count(); num1(); } public static void num1(){ num+=1;//调用的变量必须是静态变量，但是不能用this引出来
// this.num+=1;//出错,this当前类的对象，解决成员变量和局部变量同名冲突，this不能使用在由static关键字修饰的成员方法中使用

        num2();//调用的方法必须是静态方法 // count();//会报错,由于该方法不是静态方法
 } public static void num2(){ } }

package com.classTest.project;

class Test{

    public static void main(String[] args) {
        //引用类中的静态方法和静态变量,一般采用类名+"."调用,语法:类名.静态变量 或者 类名.静态成员方法
        ClassTest.num+=1;
        ClassTest.num1();
        ClassTest.num2();
    }
    }

七、构造方法的引用:

package com.classTest.project;

public class ClassTest {
    String name;
    int hobby;
    int weight;
    public ClassTest(int weight){
        this.weight=weight;
    }
    public ClassTest(String name,int hobby,int weight){
        this(weight);//经过this去引用其余重载的构造方法,该语句必须放在第一行
        this.name=name;
        this.hobby=hobby;
//      this(weight);//报错
        
    }
}

包的做用:便于管理咱们的代码

3、继承、封装、多态

一、继承(extends):提升代码的复用性

封装:使代码模块化，提升安全性，隐藏类的类部细节

　包:便于管理咱们的代码

方法的重写(向上转型)

多态的应用:

向上转型和向下转型

Java解决多继承问题用接口

二、方法分红类方法和对象方法，以static来区别，若是以静态关键字来修饰的方法是类方法，不然为对象方法

方法的重写:

①重写方法和被重写方法必须具备相同的方法名和参数列表
②重写方法的返回值类型必须和被重写方法的返回值类型相同了或者是其子类
③重写方法的不能缩小被重写方法的访问权限

三、super的使用:

（1）super.print();子类里面调用父类的方法及属性等，用super，但是在父类中不能引用super的方法及属性等
（2）super关键字和this关键字的做用相似，都是将被屏蔽了的成员变量、成员方法变为可见可用。
（3）super用在子类中，访问直接父类中的被屏蔽的内容，进一步提升代码的重要性和灵活性。super关键字不只能够访问父类的构造方法，还能够访问父类的成员，包括父类的属性、通常方法等，没法经过super访问private

条件	顺序
子类的构造方法中没有经过super显示调用父类的有参构造方法，也没有经过this显示调用自身的其余构造方法	默认先调用父类的无参构造方法
子类中的构造方法中经过super显示调用父类的有参构造方法	将执行父类相应的构造方法，而不执行父类无参构造方法
子类构造方法中经过this显示调用吱声的其余构造方法	在相应的构造方法中应用以上两条规则

四、继承的总结:
(1)子类必须经过关键字extends来实现继承
(2)子类能够重写父类的方法
(3)在子类中能够经过super关键字去访问父类的成员变量和成员方法，可是不能调用父类中private的属性和方法。
格式:super.方法名()或者super.属性,可是引用构造方法的格式:super()(无参的构造方法)、super(参数)(有参构造方法)
(4)继承中构造方法调用的顺序:先调用父类的构造方法，再调用自身的构造方法，若是有多级继承的关系，也遵循上述顺序原则

五、Object类是全部类的父类和被子类常常重写的方法

方法	说明
toString()	返回当前对象自己的有关信息,按字符串对象返回
equals()	比较两个对象是不是同一个对象，是则返回true
hashCode()	返回该对象的哈希代码值
getClass()	获取当前对象所属的类信息,返回Class对象

六、形参在方法中如何表现出来:
按基本数据类型、数组、类类型声明形式（好比:int i、int[]a、Dog dog）

七、多态

多态解决代码冗余问题，提升程序的扩展性，以及提升代码的复用性
多态：同一个引用类型，使用不一样的实例而执行不一样操做。方法重写是实现多态的基础

多态的总结:
(1)同一个引用类型，使用不一样的实例（对象）而执行不一样的操做,是具体根据实例（对象）来肯定调用相应的方法
(2)多态的条件：
a 继承是多态的基础,继承是必要条件
b 方法重写
c 父类引用指向子类对象
(3)多态的好处:提升程序的可扩性以及维护性，实际应用中，新增一个子类就至关于一个新的需求，测试类至关于业务的逻辑实现

(4)没有使用多态前的解决方案:
a 新建一个子类
b 在主人类中增长一个喂新增子类的方法
c 在测试类中去实例化(建立)子类的对象以及主人类实例化(建立)对象
该解决方案的弊端:每新增一个子类，就得去主人类中增长一个方法，并且该方法中代码是相同的，这样代码就显得冗余。
使用多态的解决方案:
a 新建一个子类
b 在测试类中去实例化(建立)子类的对象以及主人类实例化(建立)对象

若是子类中没有给方法（如:pet.eat()）,就会主动父类的方法eat()方法

八、向上转型和向下转型

（1）向上转型:子类向父类靠，如Pet pet=new Dog();将没法调用子类特有的方法
向上转型:

实现步骤:
第一步:实例化子类对象

格式:Dog dog=new Dog();
第二步:父类的引用变量指向子类对象(体现向上转型)

格式:Pet pet=dog;
第三步:实例化第三方(主人类)

格式:Master master=new Master();
第四步:父类的引用变量做为第三方(主人类)的方法实参进行传递

格式:master.playToPet(pet);

（2）向下转型:父类类型转换为子类类型，如:Dog dog=(Dog)pet;
格式:子类的类类型子类的引用变量 = （父类）

向下转型:

实现步骤:
第一步:实例化子类对象

格式:Dog dog=new Dog();
第二步:父类的引用变量指向子类对象

格式:Pet pet=dog;
第三步:父类的引用变量强制转换成子类引用变量

格式:Dog dog1=(Dog)pet;
第四步:实例化第三方(主人类)

格式:Master master=new Master();
第五步:子类的引用变量成为第三方(主人类)的方法实参进行传递

格式:master.playToPet(dog1);
第六步:修改第三方(主人类)中相应方法语法:结合instanceof运算符来判断是否真正子类类型，才能够调用相应的子类特有的方法
格式: if(pet instanceof Dog){ //形参的引用变量 instanceof 子类相应的子类类型
　　((Dog)pet).play();
}
向下转型的最终目的:即实现多态(主要体如今第三方类中)，又要让子类引用变量去引用子类中所特有的方法

（3）instanceof判断是否转型成功

（4）抽象方法与普通方法的区别
a、普通方法必需要有方法体,抽象方法不能有方法体(大括号也没有)
b、抽象方法要用abstract修饰
c、抽象方法必须存于抽象类中

抽象方法:有关键字abstract修饰的方法,它没有方法体。

注意事项:
a、抽象方法只能存在抽象类中
b、抽象方法必须在子类中重写

抽象类:有关键字abstract修饰的类,称做为抽象类

注意事项:
a、抽象类不能被实例化不能跟new 一块儿使用 error：new Car()
b、抽象类中能够有属性(成员变量)、普通方法以及抽象方法的组成

c、抽象类的抽象方法没有方法体

d、抽象类的抽象方法必须在子类中实现

（5）接口是为了实现方法里面的多继承问题，通常用于解决java多继承问题接口: a、定义:接口是经过interface关键字直接定义一个接口，不须要关键字class b、接口中的方法必定是抽象方法，可是该抽象方法能够不加abstract关键字 c、接口中的属性必定要初始化，可是接口通常用于定义静态常量格式:public final static int BRIDCOUNT=5; d、实现接口必须实现接口中全部的方法 e、接口不可以实例化(即不能跟new关键字一块儿使用)，可是能够用来声明引用变量语法:接口名引用变量 f、接口不可以继承普通类和抽象类，可是能够继承接口，实现接口必须实现接口中全部的方法，包括继承过来的接口中的方法