面向过程: 我们以前使用的是面向过程编程, 你需要清除每个实现步骤, 每个步骤每行代码都要仔仔细细的编写,
不知道过程就找不到结果, 找到实现过程就可以得到实现结果.
例如: 我们在外打工租房子, 我们需要了解每个每个房屋的出租信息, 不然是找不到房子的.
面向对象: 对象帮我们做事情, 找到对应的对象我们就可以得到想要的结果.
例如: 我们找房子不在如此的繁琐, 只要找到中介我们就不怕没有地方住, 中介会帮你找房子, 你只需支付对应的服务费即可.
面向对象的三大特征给我们带了巨大的好处, 下面我们就来讲解一下.
1. 什么是封装?
1.1 封装是面向对象的三大特征之一.
1.2 它就是把细节信息封装起来, 对外提供操作它的对应的方法.
例如: 就像一辆车, 你从来不关心它是怎么建造的, 你只需要懂怎么操作它就可以了.
2. 怎么实现封装
2.1 封装的实现方式就是将你需要封装属性提到一个公共的类中,
将属性私有化, 对外提供 setter,getter 方法, 对需要重复使用的实现过程进行抽取为方法.
3. 封装的好处
3.1 封装使整个软件开发复杂度大大降低.
3.2 将需要重复使用的实现过程进行封装, 提高代码的重用性.
3.3 你只需找到其对应的方法即可, 无需关系它是怎么实现的.
3.4 私有化数据将数据隐藏, 对无需安全考虑的数据通过 setter,getter 往外提供, 对需要考虑安全问题的数据进行私有化.
3.5 你可以对其参数进行限定, 适应你的业务范围.
例如: 就像年龄一样, 你声明的参数类型为 int,int 是可以为负值的,
但是在我们的现实生活中,
年龄是没有负值的, 这时你可以将年龄对应的 setter 方法内添加一个
if-else if-else 来限制它的范围
- package com.jq;
- /**
- * 封装
- */
- public class PackageDemo {
- /**
- * 将抽象的事物共有的属性进行私有化
- */
- private String name;
- private int age;
- /**
- * 将不需要对外提供的属性进行私有化.
- */
- private String phone;
- public String getName() {
- return name;
- }
- public void setName(String name) {
- this.name = name;
- }
- public int getAge() {
- return age;
- }
- /*
- 可以对传入参数进行限定来适应业务需求
- */
- public void setAge(int age) {
- if(age<0){
- this.age = 1;
- }else if(age>1000){
- this.age=1000;
- }else{
- this.age = age;
- }
- }
- /*
- * 无需关注代码细节, 只需调用即可
- */
- public void eat(){
- System.out.println("吃东西");
- }
- /*
- 提高代码的重用性
- */
- public Object add(Double numa,Double numb){
- return numa+numb;
- }
- public static void main(String[] args) {
- // 直接调用方法实现功能, 降低了代码的复杂度, 也无需关系代码的实现过程
- System.out.println(new PackageDemo().add(1d,2d));
- }
- }
1. 什么是继承
1.1 继承就是将共有特征或者行为进行向上抽取, 将其共有的东西进行实现或者抽象化.
例如: 小明跟小丽都有年龄, 性别和名字, 人类也有这三个特征,
人类的范畴比小明小丽这个特有个体的范围大, 所以可以将年龄,
性别和名字这三个特征向上抽取.
小明跟小丽都是人, 都有吃东西这个功能, 所以可以向上抽取,
但是小明可能是南方人, 小丽可能是北方人, 一个是吃面食, 一个是吃水稻的.
所以可以将这个共有的行为抽象化. 让小明小丽这个特有的个体来进行实现.
2. 怎么样继承
2.1 只需将共有的特征或者行为封装为对象, 然后使用 extends 这个关键字进行继承即可.
如有抽象方法需要对抽象方法进行实现.
3. 继承的好处
3.1 继承的好处是对共有的属性或者行为进行向上提取, 降低了代码的复杂度.
3.2 继承为实现多态提供了前提, 没有继承就没有多态.
4. 注意事项
4.1 继承时子类共有方法会覆盖父类的共有方法.
例如: 子类父类都有吃东西的方法, 子类是吃饭, 而父类是吃东西,
在使用多态类创建对象 ( Fu fu = new Zi() ) 时, 调用 eat 方法是时, 会是吃东西而不是吃饭.
4.2 继承时子类属性不会覆盖父类的属性.
- package com.jq;
- /**
- * 继承
- */
- abstract class human {
- // 抽取共有特征
- String name;
- int age;
- // 抽取共有方法, 特有行为让其子类实现
- public abstract void eat();
- @Override
- public String toString() {
- return "human{" +
- "name='" + name + '\'' +
- ", age=" + age +
- '}';
- }
- }
- class XiaoMing extends human{
- public XiaoMing() {
- super.name="小明";
- super.age=25;
- }
- public void eat() {
- System.out.println("吃面");
- }
- }
- class XiaoLi extends human{
- public XiaoLi() {
- super.name="小丽";
- super.age=18;
- }
- public void eat() {
- System.out.println("吃面");
- }
- }
- public class ExtendsDemo {
- public static void main(String[] args) {
- System.out.println(new XiaoMing());
- System.out.println(new XiaoLi());
- }
- }
1. 什么是多态
1.1 多态就是同一个事物但是他具有多种形态.
例如: 一只二哈, 二哈是一只狗, 二哈是犬科动物, 二哈是一直动物, 这就是多态.
2. 怎么实现多态
2.1 只需具有继承关系, 然后进行类型转换即可.
3. 多态的好处
3.1 多态切换多种形态来使用特有的方法.
4. 多态的弊端
4.1 只能使用本形态下的属性和方法.
4.2 如果在使用数组或者没有使用泛型的集合内的对象时, 需要用到子类特有的方法, 必须用 instanceof 这个关键字来进行类型判断,
否则有可能会出现 ClassCastException 这个异常.
- package com.jq;
- /**
- * 多态
- */
- class Dog {
- String name="二哈";
- public void call(){
- System.out.println("汪汪汪汪");
- }
- }
- class erha extends Dog {
- public void eat(){
- System.out.println("吃的一手好狗粮");
- }
- }
- class xiaomao {
- public void call(){
- System.out.println("喵喵喵");
- }
- }
- public class PolymorphicDemo {
- public static void main(String[] args) {
- Object[] animal = {new erha(),new xiaomao()};
- for (Object o : animal) {
- /*Dog dog =(Dog)o;
- dog.call();
- 以上代码会抛异常 java.lang.ClassCastException: com.jq.xiaomao cannot be cast to com.jq.Dog
- */
- if(o instanceof Dog){
- Dog dog =(Dog)o;
- dog.call();
- }else if(o instanceof xiaomao){
- xiaomao cat =(xiaomao)o;
- cat.call();
- }
- }
- }
- }
来源: https://www.cnblogs.com/GGYC/p/10947052.html