java三大特性（封装、继承、多态）

一、类的封装

类的封装性：将数据和操作封装为一个有机的整体，由于类中私有成员都是隐藏的，只向外部提供有限的接口，所以能够保证内部的高内聚性和与外部的低耦合性。用者不必了解具体的实现细节，而只是要通过外部接口，一特定的访问权限来使用类的成员，能够增强安全性和简化编程。

 java类封装的方法

1.私有成员变量：

通过将类的成员变量设置为私有（private）,可以隐藏类的内部状态。这意味着，这些变量智能在类的内部内访问和修改，不能直接从类的外部访问。

2.公共方法：

通过创建公共方法（public），可以提供对私有成员变量的访问和修改。这些方法被称为“getter”和“setter”方法。Getter方法用于获取私有成员变量的值，而Setter方法用于设置私有成员变量额度值

3.封装数据：

通过封装数据，我们可以控制对数据的访问，增加安全性并简化程序结构。封装使得我们不需要了解对象的内部工作机制，只需要关系提供的接口。

4.封装行为：

除了封装数据，我们可以封装行为，即方法，这意味着我们可以将相关的操作封装到一个类中，并通过公共接口（方法）来调用这些操作。

类的封装方法代码如下

public class Student{、
    /**
    *使用private修饰属性或者行为，将他们私有
    *
    *
    */
    private String name;    //姓名属性
    private String gender;    //性别属性
    private int age;    //年龄属性
    /**
    *赋值方法，设置为set方法
    *取值方法，设置为get方法
    *get方法：让对象属性刻度，如果没有在类中提供get方法，那么该属性不可读
    *set方法，让对象属性可写，如果在类中没有提供set方法，那么该属性不可写
    */
    public String getName(){    //设置name的get方法
        return name;
    }

    public void setName (String name){    //设置name的set方法
        this.name = name;
    }

    public String getGender(){    //设置gender的get方法
        return gender;
    }

    public void setGender (String gender){    //设置gender的set方法
        this.name = gender;
    }

    public String getAge(){    //设置age的get方法
        return age;
    }

    public void setAge (String age){    //设置age的set方法
        this.name = age;
    }
    //方法
    public void showInfo(){
        System.out.println (name+","+gender+","+age);
    }
}

 访问修饰符：

private:

当一个类被声明为private时，它只能被其自身访问。这是最严格的访问级别。

default:

当一个类的成员没有被声明为private、proected或public，其访问级别就是default这意味着它可以被同一个包内的其他类访问。

protected:

当一个类的成员被声明为protected时，它可以被同一个包内的其他类以及所有子类访问。

public：

当一个类的成员被声明为public时，它可以被任何其他类访问。这是最开放的访问级别。

修饰符	本类	同一个包中的类	子类	其他类
public	可以访问	可以访问	可以访问	可以访问
protected	可以访问	可以访问	可以访问	不能访问
默认	可以访问	可以访问	不能访问	不能访问
private	可以访问	不能访问	不能访问	不能访问

构造方法

构造对象时用的方法，即就是对象创建时要执行的方法 

构造方法的体现

（1）构造方法没有返回值类型，也不需要写返回值。因为它是用于构建对象的，对象创建完，方法就执行结束。

（2）构造方法名称必须和类型保持一致。

（3）构造方法没有具体的返回值

（4）当一个类没有显式的写构造方法时，使用的是默认的无参构造。

（5）同一个类内可以写多个构造方法，但是需要通过构造放方法所需要携带的参数进行区分，不能出现携带相同参数的构造方法。

构造方法格式

修饰符 构造方法名(参数列表){
        //代码快
    }

二、类的继承

类的继承性：继承性更符合认知规律，使程序更容易于理解，同时节省不必要的重复代码。通过继承创建的新类成为“子类”或“派生类”，被继承的类成为“基类”、“父类”或“超类”.

 在java程序中，如果要声明一个类继承另一个类，需要使用extends关键字；

/**
*定义persion类
*/
public Persion{
    //定义name属性
    String name;
    //定义Persion类的work方法
    public void work(){
        System.out.println("尽力的工作");
    }
}

/**
*定义学生类student继承Persion
*/
class Student extends Persion{
    //定义一个打印name的方法
    public void printName(){
        System.out.println("name="+name);
    }
}

 继承的注意事项：

（1）在java中，类只支持单继承，也就是说一个类只能有一个直接父类

（2）多个类可以继承一个父类

（3）在java中，多层继承是可以的，即一个类的父类可以再去继承另外的父类

eg c类继承自B类，而B类又可以去继承A类，这时，C类也可称作A类的子类

（4）在java中，子类和父类是一种相对概念，也就是说一个类是某个类的父类的同时，也可以是另一个类的子类

继承的特点：

（1）如果子类出现了父类中同名的成员变量，这时子类若要访问父类的成员变量，必须使用关键字super来我完成，super用来标识当前对象中包含的父类对象空间的引用。

（2）当程序中对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法，若子类不存在就会执行父类中相应的方法。

（3）在创建子类对象时，因为子类继承父类的成员变量和成员方法，所以子类会先加载父类，调用父类额度构造方法，因此子类中所有构造方法的第一行有默认的隐式super（）语句来调用父类的构造方法。如果当父类中没有空参数构造方法时，子类的构造方法必须有显示的super语句，指定要访问父类有参数的构造方法。

this关键字和super关键字的区别：

1、this关键字

this关键字用于引用当前对象的实例。它主要用于在类的非静态方法中引用当前实例，一区分实例变量和局部变量。如果局部变量和实例变量同名，可以使用this来引用实例变量。它可以用于调用同一类中的其他构造函数。还有一个不常见的用法是在静态方法中使用this，这表示该静态放阿飞是属于类而不是实例的

2、super关键字

super关键字用于引用当前对象的父类的实例。它主要用于访问父类的属性和方法，特别是在子类中覆盖了父类的方法时，可以使用super来调用父类的方法。它还可以用于调用父类的构造函数。在子类的构造函数中，可以使用super(参数列表)来调用父类的构造函数。super还可以用于访问父类的静态变量和静态方法。

三、类的多态

类的多肽性：同一操作作用域不同对象，可以有不同的解释，产生不同的执行结果。在运行时，可以通过指向父类（基类）的指针，来调用实现子类（派生类）中的方法

 多态的格式

父类类型（或接口）    变量名    =    new    子类类型（）;
变量名.方法名();

多态的主要用途：

1、代码重用：多态可以使不同的类实现同一接口或继承同一父类，从而使得相同或类似的代码可以重复使用，避免写代码的麻烦。

2、可拓展性：由于多态的存在，我们可以轻松地添加新的子类或实现类，而无需对现有代码进行修改，从而使得程序更加灵活和可扩展。

3、可维护性：多态的使用使得代码更加清晰、简介和易于理解，从而使得程序的维护和调试更加容易。

4、可替代性：由于多态的存在，我们可以在不改变现有代码的情况下，替换掉某个类的实例，从而实现不同的功能，这也能使得程序更加具有可替代性

5、降低类的使用成本：多态只需要知道对象具有某个方法。封装是让类的调用者不需要知道类的实现细节。多态能让类的调用者连这个类的类型是什么都不必知道，只需要知道这个对象具有某个方法即可。 

多态的转型

向上转型：子类对象赋值给父类引用，多态本身就是向上转型的过程。向上转型其实就是多态。

向下转型：指一个已经向上转型的子类对象，可以使用强制类型转换的格式，将父类引用转为子类应用。

向下转型格式
子类类型  变量名  =  （子类类型）父类类型变量

为了更好的进行向下转型，采用instanceof判断数据类型，如果父类包含子类，将父类转化为子类的类型。

四、抽象类

在一个类中，含有的方法只有方法名，没有方法体的类。我们称之为抽象类

//抽象方法定义的格式：
public abstract 返回值类型 方法名（参数）；

public abstract class 类名{
        语句
    }

抽象类的特点

1、抽象类由关键字abstract来修饰；

2、抽象方法也有关键字abstract来修饰，且没有方法体，连大括号都没有；

3、抽象类可以含有抽象方法，也可以含有普通方法，也可以任何方法都不含

4、抽象类不能直接创建对象（建自己的对象），因为抽象类中含有了抽象方法后，使用对象的引用去调用是没有任何意义的；

5、抽象类是可以通过多态的形式，建立子类对象，这种方式叫做：向上造型；

6、抽象类也是类，类与类之间就可以形成继承关系，当一个普通类继承了抽象类后，就需要实现抽象类的全部抽象方法，即重写；否则，当前的普通类也是一个抽象的，只继承不向上是被允许的。

7、含有构造方法的类一定是构造类，但构造类不一定有构造方法。

五、类的高级特性 

abstract（修饰抽象类）关键字的冲突

1、final（最后）

被abstract修饰的方法，强制要求子类重写，被final修饰的方法子类不能重写

2、private（私有）

被abstract修饰的方法，强制要求子类重写，被private修饰的方法子类不能重写

3、static（静态）

被static修饰的方法可以类名调用，类名调用抽象方法没有意义

static关键字

static关键字是静态的意思，可以修饰成员变量，也可以修饰成员方法

特点：

static修饰成员

1、被其修饰的成员，被该类的所有成员所共享的

2、多了一种调用方式，可以通过类名调用

3、随着类的加载而加载，优先于对象存在

static成员变量

1、共享数据

static成员方法

1、常用于工具类

final关键字

关键字的意思是最终的，不可变的，可以修饰

特点：

修饰方法：表明该方法是最终方法，不能被重写

修饰类：表明该类是最终类，不能被继承

修饰变量：表明该变量是常量，不能在此被赋值

（1）final修饰类不可以被继承，但是可以继承其他类

（2）final修饰的方法不可以被覆盖，但父类没有被final修饰，子类覆盖后可以加final

（3）final修饰的变量成为常量，这些变量只能赋值一次

（4）引用类型的变量值为对象地址值，地址值不能更改，但是地址内的对象属性值可以修改

（5）修饰成员变量，需要创建对象前赋值，否则报错

（6）我们想在类中定义一个静态常量，通常使用public static final修饰的变量来完成定义，此时变量名用全部大写，多个单词使用下划线链接

（7）接口中每个成员变量都默认使用public static final修饰，所有接口中的成员变量已是静态常量，由于接口没有构造方法，所以必须显示赋值，可以直接用接口名访问。

接口

//定义接口
public interface 接口名{}

//接口不能实例化，且接口没有构造方法

//接口和类之间是实现关系，通过 implements 关键字表示

public class 类名 implements 接口{}

//接口的子类（实现类）
要么重写接口中的所有抽象方法
要么死抽象类

特点

成员变量：只能是常量，默认修饰符：public static final

构造方法：没有

成员方法：只能是抽象方法。默认修饰符public abstract

接口可以继承多个接口，抽象类可以实现多个接口，普通类可以实现多个接口，普通类可以继承一个接口的同时实现多个接口