一.封装

1.概念

封装是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的。

2.封装原则

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问成员变量private，提供对应的getXxx()/setXxx()方法

3.封装好处

1.通过方法来控制成员变量的操作，提高了代码的安全性
2.把代码用方法进行封装，提高了代码的复用性
3.类内部的结构可以自由修改。隐藏信息，实现细节。

4.权限修饰符

当我们在一个类中定义成员变量时，会指定一个变量的类型，除此之外，还会有修饰符的部分，在此给出定义成员变量的规范格式：

// 定义变量 1.[修饰符] 变量类型变量名称; 2.[修饰符] 变量类型变量名称 = 初始值;

修饰符起到的作用从字面就可以解释，起到一个修饰和限定的作用，可以使用在成员变量之前的修饰符可以是public、protected、private、final、static。

5.封装代码


```java
代码演示：
/*学生类*/public class Student {private int number;//private修饰三个属性private int state;private int score;public Student (){}//无参构造器public Student(int number,int state,int score){this.number=number;this.state=state;this.score=score;}//有参构造器/*下面是Student类提供的get() set()方法外界可以通过他们访问！*/public void setNumber(int number){this.number=number;}public int getNumber(){return number;}public void setState(int state){this.state=state;}public int getState(){return state;}public void setScore(int score){this.score=score;}public int getScore(){return score;}
}
===============================
/*测试类*？
public class StudentDemo {public static void main(String[] args) {//无参构造方法创建对象后使用setXxx()赋值Student s1 = new Student();s1.setName("林青霞");s1.setAge(30);s1.show();//使用带参构造方法直接创建带有属性值的对象Student s2 = new Student("林青霞",30);s2.show();}
}

二.继承

1.概述

继承是面向对象语法的三大特征之一。继承可以降低代码编写的冗余度，提高编程的效率。通过继承，子类获得了父类的成员变量和方法。继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

2.继承优点

1.继承过来的字段和方法，可以像任何其他字段和方法一样被直接使用；
2.在子类中可以声明一个与父类中同名的新字段或静态方法，从而“隐藏”父类中的字段或方法；
3.可以在子类中声明一个在父类中没有的新字段和方法；
4.可以在子类中编写一个父类当中具有相同名的新实例方法，这称为“方法重写”或“方法覆盖”；
5.可以在子类中编写一个调用父类构造方法的子类构造方法，既可以隐式地实现，也可以通过使用关键字super来实现。

3.变量访问特点

在子类方法中访问一个变量，采用的是就近原则。

子类局部范围找
子类成员范围找
父类成员范围找
如果都没有就报错(不考虑父亲的父亲…)

4.代码演示

//代码演示：
class teacher{             //声明一个teacher类为父类String name;           //定义父类的成员变量name、age   int age;void show(){           //定义父类成员方法，将成员变量输出System.out.println(name);    System.out.println(age); }
}
class Student extends teacher {     //声明一个Student类为子类并继承父类
}
public class myfirst {public static void main(String[] args) {System.out.println("学生");Student student=new Student();     //声明一个Student类的实例对象studentstudent.name="Tom";                //子类调用父类的成员变量name并赋值student.age=19;                    //子类调用父类的成员变量age并赋值student.show();                    //子类调用父类的成员方法show}
}

5.继承中的关键字

1、 extends关键字
在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。
2、implements关键字
使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。

public class C implements A,B {}

3、super 与 this 关键字
super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类
this关键字：指向自己的引用。
4、final关键字

fianl关键字的作用
- final代表最终的意思，可以修饰成员方法，成员变量，类
final修饰类、方法、变量的效果
- fianl修饰类：该类不能被继承（不能有子类，但是可以有父类）
- final修饰方法：该方法不能被重写
- final修饰变量：表明该变量是一个常量，不能再次赋值
  final不能修饰构造器
  final与static搭配使用不会导致类加载

Final拓展：

5.static关键字
static的访问特点

非静态的成员方法
- 能访问静态的成员变量
- 能访问非静态的成员变量
- 能访问静态的成员方法
- 能访问非静态的成员方法
静态的成员方法
- 能访问静态的成员变量
- 能访问静态的成员方法
总结成一句话就是：
- 静态成员方法只能访问静态成员

6.继承的注意事项

Java中继承的注意事项

Java中类只支持单继承，不支持多继承
错误范例：class A extends B, C { }
Java中类支持多层继承

7.重写

方法重写的注意事项

私有方法不能被重写(父类私有成员子类是不能继承的)
子类方法访问权限不能更低(public > 默认 > 私有)
3.代码实现

代码：
public class InheritenceTest {public static void main(String[] args) {Dog dog = new Dog();dog.run();}
}class Animal {public void run() {System.out.println("animal is running");}
}class Dog extends Animal {public void run() {System.out.println("Dog is running");super.run();//调用父类的run方法}}
}// 方法重写与方法重载之间的关系：重载发生在同一个类内部的两个方法或多个方法。重写发生在父类和子类之间。

三.多态

1.多态概述

什么是多态

同一个对象，在不同时刻表现出来的不同形态
多态的前提
- 要有继承或实现关系
- 要有方法的重写
- 要有父类引用指向子类对象

2.代码演示

代码：
/*接口类*/
public interface Jumpping {void Jump();}
/*测试类*/
public class AnimalDemo {public static void main(String[] args) {Jumpping j=new Cat();//父类引用指向子类也叫向上转型j.Jump();}}

3.成员访问特点

成员访问特点

成员变量

编译看父类，运行看父类
成员方法

编译看父类，运行看子类

4.多态的转型

向上转型

父类引用指向子类对象就是向上转型
例子：Animal a=new Cat()
向下转型

格式：子类型对象名 = (子类型)父类引用;
例子：Cat c=(Cat) Animal

5.多态的好处与弊端

好处

提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作
弊端

不能使用子类的特有成员

Java面向对象的三大特征（封装，继承，多态）相关推荐

python多态的三种表现形式_python小结----面向对象的三大特征(封装,继承,多态)
面向对象的三大特征: 封装,继承,多态面向对象的编程思想核心:高类聚,低耦合–程序的设计模式范畴封装什么是封装: 在面向对象编程的思想中,对代码进行高度封装,封装又叫包装封装就是指将数据或者函 ...
Day55-每日一道Java面试题-Java 面向对象编程三大特性: 封装继承多态
Java 面向对象编程三大特性: 封装继承多态封装封装把一个对象的属性私有化,同时提供一些可以被外界访问的属性的方法,如果属性不想被外界访问,我们大可不必提供方法给外界访问.但是如果一个类没有 ...
Python学习笔记④——类、面向对象的三大特征 [封装+继承+多态]
✅ Blogger Learns Python is for learning the "Deep Learning". 文章目录一.面向对象编程的简介二.类与对象 -- 基础 ...
OC面向对象的三大特征(封装继承多态)习题2 复合
复合:一个类中有一个成员变量是另外一个类的对象. 比如我现在要制作一台电脑,电脑需要CPU,显示器,鼠标和键盘等.这些东西的研发都是很复杂的过程.如果现在有成型的CPU等组件,就可以直接用这些组件攒一 ...
三大特征封装继承多态
''' 1.面向对象与面向过程面向过程:核心过程二字,过程即解决问题的步骤,就是先干什么后干什么基于该思想写程序就好比在这是一条流水线,是一种机械式的思维方式优点:复杂的过程流程化缺点:扩展性 ...
面向对象的四大特征封装继承多态抽象
1.封装广义: 类方法包的定义本身就是一种封装狭义: 在设计一个类的时候将所有的属性设置为私有的并对各个私有的属性设计相应的存/取方法来完成对属性的使用私有化只能代表封装的特性可 ...
java的知识点11——面向对象的三大特征之一继承、instanceof 运算符、方法的重写override、Object类基本特性、toString方法
面向对象的三大特征:继承.封装.多态继承的实现继承让我们更加容易实现类的扩展.子类是父类的扩展使用extends实现继承 package cn.sxt;public class Test {pu ...
java面向对象的三大特征是6_Java面向对象的三大特征
面向对象的本质:以类的方式组织代码,以对象的方式组织数据. 面向对象三大特性:封装继承多态封装: 概念: 隐藏对象内部的复杂性,只对外公开简单的接口.便于外界调用,从而提高系统的可扩展性,可维护 ...
深入理解Java面向对象三大特性封装继承多态
1.封装封装的定义: 首先是抽象,把事物抽象成一个类,其次才是封装,将事物拥有的属性和动作隐藏起来,只保留特定的方法与外界联系为什么需要封装: 封装符合面向对象设计原则的第一条:单一性原则,一个类 ...

Java面向对象的三大特征（封装，继承，多态）