JavaSE基础-（1）面向对象特征

系列文章目录

JavaSE基础-（1）面向对象特征
JavaSE基础-（2）Java基础语法：Hello World
JavaSE基础-（3）类和对象
JavaSE基础-（4）数据类型
JavaSE基础-（5）流程控制
JavaSE基础-（6）异常处理
JavaSE基础-（7）修饰符

---

ps：以上文章属于博主 菜菜bu菜 专栏 《今天开始学Java》| 欢迎关注收藏哟~

---

前言

Java作为编程初学者的入门语言之一，也是现如今最受欢迎的跨平台编程语言。有Java的基础也可以自己学习大数据，转行大数据。据官方数据统计，在全球编程语言工程师的数量上，Java编程语言的程序员数量位居首位。

一、封装

编程分为面向对象编程和面向过程编程，我们熟悉的C语言是面向过程的，而C++/Java则死面向对象的。他们的本质都是都是写代码，最终转译成机器码去执行，

Java里说，万物皆对象，如果说java的面向对象设计思想是java火起来的原因，那么Spring设计思想让Java的光彩放大。

封装（Encapsulation）是面向对象方法的重要原则，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法，就是把对象的属性和操作（或服务）结合为一个独立的整体。

封装的具体功能归纳总结就6个字：高内聚，低耦合

具体指的是：

• 良好的封装能够减少耦合。
• 类内部的结构可以自由修改。
• 可以对成员变量进行更精确的控制，将类的某些信息隐藏在类的内部（private），不允许外部程序进行直接的访问调用。
• 隐藏对象的细节信息，提供访问的对外接口（setter、getter方法）

实例

让我们来看一个java封装类的例子：

Encapsulation.class 封装类

  package javase;//Class文件的包名
 
    /**
     * 封装实例
     * @author 菜菜bu菜
     * @Override 重写
     *  
     */
 
    public class Encapsulation {

            private String name;
            private String age;
            public String csdn_name="菜菜bu菜";

            public Encapsulation(String name, String age) {
                    super();
                    this.name = name;
                    this.age = age;
            }
            public String getName() {
                    return name;
            }
            public void setName(String name) {
                    this.name = name;
            }
            public String getAge() {
                    return age;
            }
            public void setAge(String age) {
                    this.age = age;
            }

            @Override
            public String toString() {
                    return "encapsulation [name=" + name + ", age=" + age + "]";
            }
	
    }

RunEncapsulation .class 实现方法

package javase;//自己包名
 
/**
 * 封装实例
 * @author 菜菜bu菜
 * @Override 重写
 *  
 */
public class RunEncapsulation {
	
	public static void main(String[] args) {
		Encapsulation encapsulation=new Encapsulation("小菜","18");
		System.out.print(encapsulation.toString()+"\n");
		System.out.print(encapsulation.csdn_name+"\n");
		System.out.print(encapsulation.getName()+"\n");
//		System.out.print(encapsulation.name+"\n");
	}
}
 

结果

encapsulation [name=小菜, age=18]
菜菜bu菜
小菜

我们可以看到具有public的属性可以直接访问（非常不安全！），而private的方法需要getter和setter方法才能访问，如果想强行访问的话则会报错！！！

二、继承

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

例如，A类继承B类，那么A是子类，B是父类，通俗的理解，A（子类）继承了B（父类）的一些公共属性和方法。

生活中的继承

继承格式

class 父类 {
}
 
class 子类 extends 父类{
}

实例

 
/** 
 * 定义抽象类，动物
 * @author 菜菜bu菜
 *
 */
public abstract class Animal {
	
	// 名字
	protected String name;
	
	// 食物
	protected String food;
 
	// 食用性
	protected Boolean eat;
	
	// 是否可以食用 方法定义
	public boolean isEat() {
		return eat=true;
	}	
	
	// 吃食物，抽象方法定义
	public void eatFood() {
		System.out.println(this.name + " eat food is "  +  this.food);
	}
	
	
}
 
/*
 * Animal-鸡
 */
class Chicken extends Animal{
	
	/* 
	 *  因为封装了，你没办法修改鸡的食用性，这是封装好处的具体表现
	 */
	
	public Chicken() {
		this.eat = false;
		this.food = "insect";
		this.name = "chicken";
	}
 
}
 
/*
 * Animal-宠物pig
 */
class Pig extends Animal{
	
	public Pig() {
		this.eat = false;
		this.food = "grass";
		this.name = "pig";
	}
	@Override
	public boolean isEat(){
		return eat;
	}
 
	@Override
	public void eatFood() {
		System.out.println("override method define pig how to eat food");
	}
 
	
}

三、多态

多态是同一个行为具有多个不同表现形式或形态的能力。

多态就是同一个接口，使用不同的实例而执行不同操作。你可以定义一种抽象类，并且创建抽象类的具体实现，之后所有子类对象创建可以用父类去接收，在执行方法时，父类引用指向子类对象，方法也是子类的方法，都是父类，指向不通子类，执行方法结果不一样，就是多态。

多态存在的三个必要条件

• 继承
• 重写
• 父类引用指向子类对象：Parent p = new Child();

多态的特点

• 消除类型之间的耦合关系，实现低耦合
• 灵活性、 接口性、简化性：简化代码的编辑与修改
• 可扩充性：子类继承父类
• 可替换性：对于存在的代码具有可替代性

实例

Feature .class 封装 继承 多态 简单理解

package javase;
 
public class Feature {
 
	// java 封装 继承 多态  简单理解表达
	public static void main(String[] args) {
		
		// 创建动物对象 鸡  宠物猪
		// 封装体现，创建对象不能去修改他的属性
		Animal animal1 = new Chicken();
		Animal animal2 = new Pig();
		
		// 判断食用性 继承体现
		System.out.println(animal1.isEat());//true
		System.out.println(animal2.isEat());//false
 
		
		// 吃东西  多态体现，同一个行为具有多个不同的表现形式
		animal1.eatFood();//chicken eat food is insect
		animal2.eatFood();//override method define pig how to eat food
		
		
		// 多态 父类引用指向子类对象
		animal2 = new Chicken();
		animal2.eatFood();//chicken eat food is insect
 
		
	}
}

输出

true
false
chicken eat food is insect
override method define pig how to eat food
chicken eat food is insect

总结

以上就是今天要讲的内容，本文仅仅简单介绍了面向对象的三大特征，封装、继承、多态。理解这三个特性在以后的学习中有很大的作用！熟练的使用多态，继承，封装也可以在软件设计开发中很好的提高开发效率。