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

一、类的概念:

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

package com.classTest.project;

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

}

二、定义方法的几点说明

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

例子:

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

⑴整型(int)

⑵浮点型(float)

⑶字符串类型(String)

⑷字符型(char)

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';
    }
}

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

⑴数组

⑵类

⑶接口

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

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

3、参数列表:

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

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

　　　引用数据类型为实参时，数组是把数组名传入，类是把对象名传入，接口一般不做为实参传入

例子:

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

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

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

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

例子:

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

4、方法的注意事项:

1、方法中不能定义方法

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

2、实参不能带数据类型

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

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

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

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

三、构成方法:

1、为什么要用构造方法：
                               构造方法相当于是提供一个场所，为创建一个对象而提供的一个场所。

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

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

　　②无返回类型

　　③如果在类中没有定义构造方法，系统默认会创造一个无参数的构造方法，只要在类中定义自己的构造方法，系统便不会再创造参数的构造方法

3、带参数的构造方法:可以为成员变量初始化

getter and setter 的作用:

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

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

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

①方法是否在同一个类中

②方法名是否相同

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

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

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

6、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();
    }
    }

7、构造方法的引用:

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);//报错

    }
}

包的作用:便于管理我们的代码

三、继承、封装、多态

1、继承(extends):提高代码的复用性

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

　包:便于管理我们的代码

   方法的重写(向上转型)

  多态的应用:

                 向上转型和向下转型

   Java解决多继承问题用接口

2、方法分成类方法和对象方法，以static来区别，如果以静态关键字来修饰的方法是类方法，否则为对象方法

方法的重写:

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

3、super的使用:

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

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

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

5、Object类是所有类的父类和被子类经常重写的方法

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

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

7、多态

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

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

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

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

8、向上转型和向下转型

（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、接口不能够继承普通类和抽象类，但是可以继承接口，实现接口必须实现接口中所有的方法，包括继承过来的接口中的方法