Java的四个基本特性：封装、继承、多态和抽象
一、抽象：将一类对象的共同特征总结出来，然后构造成类的过程（包括数据抽象和行为抽象）。抽象只关注对象的属性和行为，不关注行为的细节。
人都有名字和年龄
二、封装：把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义好的接口。
1、作用：
（1）保证数据的安全性，防止调用者随意更改数据。（例如，我们在封装一些常用的工具类时，会把类的无参构造器私有化或者在类名前使用abstract修饰，不准创建该类，达到只能调用，不能修改的效果）
（2）提高代码的复用性。（把公用的方法放到一个类中，谁需要谁直接就调用）
2、使用修饰符来限定调用权限
| 修饰符 | 类内部 | 同一个包 | 子类 | 任何地方 |
| private | √ | |||
| 无 | √ | √ | ||
| protected | √ | √ | √ | |
| public | √ | √ | √ | √ |
比方说，使用private修饰的字段，只能在本类调用，在其他类调用不到。而使用protected修饰的字段，则只要是在同一个包下，都能调用。
private int age； protected String name；
3、在日常开发中，使用public修饰类（可以在当前项目中任何地方访问），使用private修饰字段（表示当前类私有的，类访问权限，只能在本类中操作，离开本类之后就不能直接访问）
并且，为了使这个类具有比较健全的功能，我们在开发中还会为这个类编写：构造器、getter方法、setter方法等等。
（1）为类加入构造器（也叫构造方法）
1）如果没有为类编写构造器，那么就会默认生成一个空参构造器，通过构造器，创建对象。
2）构造器（也叫构造方法），可以方法重载，空参构造器、一个参数构造器、两个参数构造器、多个参数构造器、满参构造器，根据具体需要使用。
3）构造器名称必须和类名相同。
4）构造器不能有返回类型。
5）构造器（也叫构造方法）不能使用修饰符 final、abstract和static修饰
6）特别地，在创建工具类时，为了防止调用者恶意修改，即只允许调用者通过类名调用方法，不允许创建对象，有两种做法，一种是使用abstract修饰工具类，一种是使用private修饰构造器。
（2）为类编写getter方法和setter方法，用来操作数目（获取和存储数据）
getter 方法：用于返回某一个字段的值
setter 方法：用来给某一个字段设置值
1），而在日常开发中，我们可以手动添加getter和setter方法
2）也可以使用插件“Lombok”，使用注解的形式实现功能
@Getter
@Setter
public class People {
private String name; // 名字
private int age; // 年龄
}** 这里，是比较有争议的；在日常开发中，有的公司喜欢使用Lombok，有些却很抵触。很显然，Lombok除了注解实现了getter和setter方法外，还提供了实现构造器等的方法，减少了代码量，也使代码变得更简洁。赞！！！
但是，使用Lombok会是代码耦合，也就是，以后必须使用Lombok不然程序就会报错，并且，开发团队中，一个人使用Lombok，其他的开发成员，也必须在项目中使用Lombok，这又是耦合。
而我的经验告诉我，使用Lombok开发时更爽，但是编写普通的getter、setter方法，可以加上对应的注解，会让后面的开发、测试和维护都更方便。
比如，我们在getter方法上加上注解 /** 名字*/
那么，我们在之后的开发中，都能很容易看到这个字段所代表的含义。当然，在小项目中可能看不出什么，但是，当项目很大时，实体类成百上千时，你会发现，有这么一个注解，是多么地幸福！！后期维护的人员，也会很感恩，今日这个写了注释的人(*^▽^*)
3）JavaBean 规范
类必须使用 public 修饰
必须保证有公共无参数构造器
，即使手动提供了带参数的构造器，也得手动提供无参数构造器
字段使用 private 修饰，
每个字段提供一对 getter
三、继承：从已有类得到继承信息创建新类的过程。被继承的类叫父类（也叫基类），继承父类的类叫子类（也叫拓展类、派生类）。一般地，在父类中存放多个子类的共同字段和方法，在子类中存放自己特有的字段和方法。
1、作用：
（1）可以解决多个类存在共同代码的问题。
（2）继承让变化中的软件系统有了一定的延续性
（3）继承是封装程序中可变因素的重要手段。
2、注意：
（1）Java 中类只支持单继承，但是支持多重继承。也就是说一个子类只能有一个直接的父类，父类也可以再有父类（例如可以“A类 extends B类”，然后“B类 extends C类”；但是不能“A类 extends B类，C类” ）。
（2）Object 类是 Java 语言的根类，任何类都是 Object 的子类，要么是直接子类，要么是间接子类。
（3）子类继承父类之后，可以拥有到父类的某一些成员（字段和方法），但是需要根据访问修饰符来判断：
- 如果父类中的成员使用 public 和 protected 修饰，子类都能继承.
- 如果父类和子类在同一个包中，使用缺省访问修饰的成员，此时子类可以继承到
- 如果父类中的成员使用 private 修饰，子类继承不到。private 只能在本类中访问
- 父类的构造器，子类也不能继承，因为构造器必须和当前的类名相同
3、在继承中，方法的调用顺序：
4、实例代码
public class People {
private String name; // 名字
private int age; // 年龄
}
public class Girl extends People{
// 因为继承了People类，所以也拥有字段name 和 age
}
public class Boy extends People{
// 因为继承了People类，所以也拥有字段name 和 age
}5、方法覆盖。
可是当父类的某个方法不适合子类本身的特
public class People {
// 父类中的方法
public void hisName() {
System.out.println("他叫张大仙");
}
}public class Boy extends People{
// 子类要想实现自己特有的功能,可以直接覆盖父类的方法
@Override
public void hisName() {
System.out.println("不想叫张大仙, 叫张冰心");
}
}（2）方法覆盖的细节（private 修饰的方法不能被子类所继承，也就不存在覆盖的概念），其他要求：
- 实例方法签名必须相同 (方法签名= 方法名 + 方法的参数列表)
- 子类方法的返回值类型是和父类方法的返回类型相同或者是其子类
- 子类方法中声明抛出的异常小于或等于父类方法声明抛出异常类型
- 子类方法的访问权限比父类方法访问权限更大或相等
6、抽象方法和抽象类
（1）使用 abstract 修饰的方法，称为抽象方法。
1）语法格式： public abstract 返回类型 方法名（参数）
2）使用 abstract 修饰，没有方法体，留给子类去覆盖
3）抽象方法必须定义在抽象类或接口中
（父类）
public abstract class Person {
public abstract void yourName();
}（子类：在子类必须提供具体的实现，不然报错）
public class Boy extends Person{
@Override
public void yourName() {
System.out.println("我是子类方法我来实现");
}
}（2）使用 abstract 修饰的类，成为抽象类
- 抽象类不能创建对象
- 抽象类中可以同时拥有抽象方法和普通方法
super 关键字
在子类中的某一个方法中需要去调用父类中被覆盖的方法
public class People {
public void hisName() {
System.out.println("他叫张大仙");
}
}（子类）
public class Girl extends People{
/**
* 拥有父类的hisName方法 和 子类自己的方法
*/
public void nameAndAge(){
super.hisName(); // 父类的hisName方法
System.out.println("子类自己的方法");
}
/**
* 子类通过覆盖,形成的自己的方法
*/
@Override
public void hisName() {
System.out.println("不想叫张大仙, 叫张冰心");
}
}如果没有使用关键字super，那么就会调用本类的hisName()方法
四、多态：多态是指允许不同子类型的对象对同一消息作出不同响应。
1、多态操作的两种实现方式
（1）操作继承关系
父类 变量名 = new 子类();
// 父类
public class People {
}// 子类
public class Girl extends People{
}public class Test {
People p = new Girl(); // 继承关系
}（2）操作实现关系.
接口 变量名 = new 实现类();
// 接口
public interface Man {
}// 实现类
public class BadMan implements Man{
}
public class Test {
Man m = new BadMan(); // 接口和实现类关系
}2、重写和重载
（1）方法重载（overload）实现的是编译时的多态性（也叫前绑定）。
- 参数类型、个数、顺序至少有一个不相同。
- 不能重载只有返回值不同的方法名。
- 存在于父类和子类、同类中。
（2）方法重写（override）<也叫方法覆盖> 实现的是运行时多态性（也叫后绑定）
- 方法名、参数、返回值相同。
- 子类方法不能缩小父类方法的访问权限。
- 子类方法不能抛出比父类方法更多的异常(但子类方法可以不抛出异常)。
- 存在于父类和子类之间。
- 方法被定义为 final 不能被重写。
面向对象的三大特征：封装、继承、多态
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。
文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/117820.html
