Java的三大特性是什么，很多新手对此不是很清楚，为了帮助大家解决这个难题，下面小编将为大家详细讲解，有这方面需求的人可以来学习下，希望你能有所收获。
成都地区优秀IDC服务器托管提供商(创新互联).为客户提供专业的温江服务器托管,四川各地服务器托管,温江服务器托管、多线服务器托管.托管咨询专线：18982081108
Java的三大特性：封装、继承、多态
Java中关于访问权限的四个修饰符，表格如下
| private | friendly（默认） | protected | public | |
|---|---|---|---|---|
| 当前类访问权限 | √ | √ | √ | √ |
| 包访问权限 | × | √ | √ | √ |
| 子类访问权限 | × | × | √ | √ |
| 其他类访问权限 | × | × | × | √ |
其中比较尴尬的是protected修饰符，有点卡在中间，不上不下的感觉
因为它不适合用来修饰属性
假设用它修饰属性，那么任何一个人都可以通过继承这个类，来直接访问到这个类的属性，从而破坏"封装性"
什么是抽象类？
抽象类就是用abstract修饰，且不能被直接初始化的类，但是可以通过子类来初始化 比如：Father father = new Son()
对应的，抽象方法就是用abstract修饰的方法
抽象方法是一种很特殊的方法，它没有方法体，即方法实现代码为空，比如abstract public void fun();
抽象方法一般在子类中进行实现，它就好像是在说：我不写代码，我只是声明一个方法名，剩下的交给我的子孙后代（继承类）去做
抽象类有一个很重要的特点：抽象类可以没有抽象方法，但是如果一个类有抽象方法，那么这个类肯定是抽象类
为什么会有抽象类
解耦，使代码结构更加清晰
因为抽象类不能被直接创建为对象，它只是作为一个通用接口来供别人实现和调用，所以这样就使得抽象的代码更加清晰（它只声明方法，不实现方法） 就好比，老板和员工，老板负责分发任务，员工负责去具体的实现任务
好了，关于抽象类，先介绍到这里，更详细的后面的章节再深入
重载和覆写是两个很容易混淆的概念
重载：同一个类中，一个方法的多种表现形式（参数类型不同，参数个数不同）
覆写：继承设计中，子类覆盖父类的方法（也可以叫做重写，不过这样跟重载有点混淆，所以个人喜欢叫做覆写）
他们之间的区别如下
| 重载 | 覆写 | |
|---|---|---|
| 访问权限 | 可以不同 | 可以不同（但是子类的可见性不能比父类的低） |
| 方法返回值 | 可以不同 | 相同 |
| 参数类型 | 不同（充分条件） | 相同 |
| 参数个数 | 不同（充分条件） | 相同 |
这里要注意几点
覆写时，子类的方法访问权限不能低于父类，比如父类方法为public，那么子类也只能为public
重载时，访问权限和方法返回值，不能作为用来判断一个方法是否为重载的依据；只能说重载允许不同的访问权限和返回值
代码示范如下，
重庆分公司
重庆分公司
// 覆写一：正确示范
@Override
public void fun(){
System.out.println("son fun");
}
// 覆写二：错误示范，访问权限低了
@Override
private void fun(){
// 报错：'fun()' in 'SonDemo' clashes with 'fun()' in 'Father'; attempting to assign weaker access privileges ('private'); was 'public'
System.out.println("son fun");
}@Override这个是干嘛的？之前没见过啊
这个修饰符用来说明这个方法是覆写方法，不写也可以，系统会自己识别方法是不是覆写的
那为啥还要多此一举呢？用系统默认的识别机制不好吗？
要多此一举；不好；
因为加了注解，代码可读性更高，代码更加规范，别人看了代码后，立马就知道这个方法是覆写方法
重载用图展示可能会更加清晰
图示解释：
参数类型和参数个数，只要满足其一，就可以说这个方法被重载了
访问权限和方法返回值用虚线框，是为了说明他们两个只是重载的一个附加表现形式（可有可无），不能作为重载的判断依据
下面用代码演示下
// 基础方法
public void fun1(int a){
}
// 重载一：参数个数不同
public void fun1(){
}
// 重载二：参数类型不同
public void fun1(float a){
}
// 重载三：错误示范，仅仅用访问权限的不同来重载
private void fun1(int a){
// 编译报错：'fun1(int)' is already defined
}
// 重载四：错误示范，仅仅用返回值的不同来重载
public int fun1(int a){
// 编译报错：'fun1(int)' is already defined
return 0;
}下面进入正文，开始顺序介绍这三大特性
就是把类的属性私有化(private修饰），再通过公有方法(public)进行访问和修改
为什么要封装呢？
追踪变化：可以在set方法中，编写代码来追踪属性的改变记录
public void setName(String name) {
System.out.println("名字即将被修改");
System.out.println("旧名字：" + this.name);
System.out.println("新名字：" + name);
this.name = name;
}修改底层实现：在修改属性名时，不会影响外部接口对属性的访问
比如：name属性改为firstName和lastName，name就可以在get方法中修改返回值为firstName+lastName，对外接口没变化
// 修改前
private String name;
public String getName() {
return name;
}
// 修改后
private String firstName;
private String lastName;
// 方法名不用变，只是方法内容作了修改
public String getName() {
return firstName + lastName;
}校验数据：可以在set方法中，校验传来的数据是否符合属性值的设定范围，防止无效数据的乱入
public void setAge(int age) throws Exception {
if(age>1000 || age<0){
throw new Exception("年龄不符合规范，0~1000");
}
this.age = age;
}如果子类继承了父类，那么子类就可以复用父类的方法和属性，并且可以在此基础上新增方法和属性
这里要注意的一点是：Java是单继承语言，即每个类只能有一个父类
这里还要普及一个常识：如果一个类没有指定父类（即没有继承任何类），那么这个类默认继承Object类
为什么要用继承呢？
为了代码复用，减少重复工作
单继承不会太局限吗？为啥不用多继承？
因为多继承会导致"致命方块"问题（因为像扑克牌的方块符号）
比如A同时继承B和C，然后B和C各自继承D
B和C各自覆写了D的fun方法
那这时A该调用哪个类的fun方法呢
下面用图来说话
那为什么叫致命方块，而不是致命三角形呢？那个D类好像是多余的
不多余
这个D类其实就是上面讲到的抽象类的作用：将共有的部分fun()抽象出来（或者提供一个基础的实现），然后子类分别去实现各自的，这也是多态的一种体现（下面会将多态）
如果没有D类，那么B和C的fun()就会存在重复代码，这时你可能就想要搞一个父类出来了，这个父类就是D类
那要怎么判断继承类设计得好不好呢？
通过is-a关系来判断
is-a关系指的是一个是另一个的关系，男人是人（说得通），人是男人（一半说得通）
用is-a关系可以很好地体现你的继承类设计的好还是坏
如果子类都可以说是一个父类，那么这个继承关系设计的就很好（男人是人，is-a关系）
如果子类和父类只是包含或者引用的关系，那么这个继承关系就很糟糕（猫是猫笼，包含关系）
有没有什么办法可以阻止类的继承？就像private修饰符用来封装属性，其他人访问不到一样
有啊，final修饰符可以阻止类的继承
这里重点讲一下final修饰符
final可以用来修饰属性、方法、类，表示他们是常量，不可被修改的
final修饰属性：属性是常量，必须在定义时初始化，或者构造函数中初始化
final修饰方法：方法不能被覆写
final修饰类：类不能被继承
说到final，有必要提一下内联
内联指的是，如果一个方法内容很短，且没有被其他类覆写时，方法名会被直接替换为方法内容
比如：final getName()这个方法可以内联为name属性
再比如：getSum(){return a+b},会直接被内联为a+b
为什么会有内联这个东西呢？
因为这样可以提高效率（细节：CPU在处理方法调用的指令时，使用的分支转移会扰乱预取指令的策略，这个比较底层，这里先简单介绍，后面章节再深入）
那它有没有什么缺点呢？
有，如果一个方法内容过长，又误被当做内联处理，那么就会影响性能
比如你的代码多个地方都调用这个方法，那么你的代码就会膨胀变得很大，从而影响性能
那有没有办法可以解决呢？
有，虚拟机的即时编译技术
即时编译会进行判断，如果一个方法内容很长，且被多次调用，那么它会自动关闭内联机制，防止代码膨胀
字面理解，就是多种形态，在Java中，多态指的是，一个类可以有多种表现形态
多态主要是 用来创建可扩展的程序
像我们上面提到的继承就是属于多态的一种
还有一种就是接口（interface）
接口类一种是比抽象类更加抽象的类
因为抽象类起码还可以实现方法，但是接口类没得选，就只能定义方法，不能实现
不过从Java8开始，接口支持定义默认方法和静态方法
接口的默认方法（default修饰符）和静态方法（static修饰符)，会包含方法内容，这样别人可以直接调用接口类的方法（后面章节再细讲）
这样你会发现接口变得很像抽象类了，不过接口支持多实现（即一个类可以同时实现多个类，但是一个类同时只能继承一个类）
这样一来，Java相当于间接地实现了多继承
下图说明继承和实现的区别：单继承，多实现
多态一般用在哪些场景呢？
场景很多，这里说两个最常用的
场景一：方法的参数，即方法定义时，父类作为方法的形参，然后调用时传入子类作为方法的实参
场景二：方法的返回值，即方法定义时，父类作为方法的返回值，然后在方法内部实际返回子类
代码示范如下：
public class PolyphorismDemo {
public static void main(String[] args) {
PolyphorismDemo demo = new PolyphorismDemo();
//场景一：形参，将猫（子类）赋值给动物（父类）
demo.fun(new Cat());
//场景二：返回值，将猫赋值给动物
Animal animal = demo.fun2();
}
public void fun(Animal animal){
}
public Animal fun2(){
return new Cat();
}
}
class Animal{
}
class Cat extends Animal{
}看完上述内容是否对您有帮助呢？如果还想对相关知识有进一步的了解或阅读更多相关文章，请关注创新互联行业资讯频道，感谢您对创新互联的支持。
