面向对象的四大特征（非常重要）

最新推荐文章于 2024-06-18 10:21:34 发布

旋律~学

最新推荐文章于 2024-06-18 10:21:34 发布

阅读量5.5w

点赞数 57

分类专栏： JAVA基础文章标签： java

本文链接：https://blog.csdn.net/qq_42429369/article/details/84929377

版权

JAVA基础专栏收录该内容

15 篇文章 4 订阅

订阅专栏

面向对象四大特征：抽象，封装，继承，多态（非常重要）

1.抽象

定义：抽象是将一类对象的共同特征总结出来构造类的过程,包括数据抽象和行为抽象两方面,抽象只关注对象的哪些属性和行为,并不关注这此行为的细节是什么

1.1 研究事物的静态特征(属性)

1.2 研究事物的动态特征(方法/函数)

1.3 形成结果(类,class)

1.4 类和对象相互转变(new)

举例说明：
学生有姓名，有年龄，有身份证号，这些都是静态特征，即属性
学生会吃饭，会睡觉，会学习，这些都是动态特征，即行为。
代码实现：

Student.java

public class Student {
	//1.1 研究事物的静态特征(属性)
	String name;
	int age;
	String cardNo;
	//1.2 研究事物的动态特征(方法/函数)
	/*
	 * 吃饭
	 */
	void eat(){
		System.out.println("吃饭.....");
	}
	/*
	 * 睡觉
	 */
	void sleep(){
		System.out.println("睡觉.....");
	}
	/*
	 * 学习
	 */
	void learn(){
		System.out.println("学习.....");
	}
	public static void main(String[] args) {
	//声明一个学生类型的变量，指向内存当中学生的一个实例（1.3-1.4）
		Student s1 = new Student();  //类到对象
		s1.name = "李四";
		s1.age = 23;
		s1.cardNo = "13012411";
		System.out.println("姓名："+s1.name+",年龄："+s1.age+",身份证号:"+s1.cardNo);
		s1.eat();
		s1.sleep();
		}
}

2.封装

定义：通常认为封装是把数据和操作数据的方法绑定起来,对数据的访问只能通过已定义的接口.面向对象的本质就是将现实世界描绘成一系列完全自治,封闭的对象,可以说,封装就是隐藏一切可隐藏的东西,只向外界提供最简单的编程接口。封装给对象提供了隐藏内部特性和行为的能力，对象提供一些能这被其它对象访问的方法来改变它内部的数据。

2.1.提供构造方法(有了构造方法才能通过new去构建一个对象 1.构造方法必须和类名称一样2.构造方法不能有返回值)

空参构造系统默认存在，但是当你手动加入了有参构造，默认的空参构造将不再存在

	//空参构造
	public Student(){ };
	//有参构造
	Student(String name){
		this.name = name;
		System.out.println("初始化成功...");
	}
	//有参构造
	Student(String name,int age,String cardNo){
		this.name = name;
		this.age = age;
		this.cardNo = cardNo;
		System.out.println("初始化成功...");
		***********************
		//有了构造，在主方法中便可以创造对象
		Student s1 = new Student();    空参构造
		Student s2 = new Student("王五");  //有参构造
		Student s3 = new Student("赵六", 22, "13012412");  //有参构造
		
	}

许许多多的构造方法形成了多态（重载），这个下边会讲到。

2.2 静态块(做的类的初始化的工作,执行在new之前)

静态块用于放创建对象前要做的一系列事情，比如说一个学生，首先要被孕育，然后出生…等等

static{
		yunyu();
		born();
	}
	static void yunyu(){
		System.out.println("孕育");
	}
	static void born(){
		System.out.println("出生");
	}

2.3 控制访问

在这里插入图片描述
具体情况具体分析

3.继承（关键字：extends）

目的：对父类和方法的复用

继承是从已有类得到继承信息创建新类的过程,继承让变化中的软件系统有了一定的延续性,同时继承也是封装程序中可变因素的重要手段.子类继承父类属性(静态特征)和方法(动态特征),继承必须遵循封装当中的控制访问

举个例子
动物分为哺乳动物和爬行动物，哺乳动物又包括人类，所以说，哺乳动物，爬行动物都与动物存在父子关系，而哺乳动物与人类也存在父子关系，父亲有的行为和属性，儿子理应也有
代码说明：
Animal.java

package com.oracle.object.extend;
/**
 * 动物类
 * @author 
 *
 */
public class Animal {

	
	String name;
	
	int age;
	
	int sex;
	
	void eat(){
		
		System.out.println(name + "is eating.......................");
	}
	
	void sleep(){
		
		System.out.println(name + "is sleeping.......................");
	}
}

BuRuAnimal.java

package com.oracle.object.extend;

public class BuRuAnimal extends Animal{

	
	public static void main(String[] args) {
		
		BuRuAnimal zhangSan = new BuRuAnimal();
		
		
		zhangSan.age = 21;
		zhangSan.name = "张三";
		zhangSan.sex = 0;
		
		System.out.println(zhangSan.name + "的年龄是" + zhangSan.age + "岁，性别是:" + (zhangSan.sex == 0 ? "男" : "女"));
		
		
		zhangSan.eat();
		
		zhangSan.sleep();
	}
}

PaXingAnimal.java

package com.oracle.object.extend;

public class PaXingAnimal extends Animal{
	
  
	public static void main(String[] args) {
		
		PaXingAnimal paXingAnimal = new PaXingAnimal();
		
		paXingAnimal.age = 10;
		
		paXingAnimal.name = "鳄鱼";
		
		paXingAnimal.sex = 0;
		
		System.out.println(paXingAnimal.name + "的年龄是" + paXingAnimal.age + "岁，性别为:" + paXingAnimal.sex);
		
		
		paXingAnimal.eat();
		
		paXingAnimal.sleep();
		
	}
}

Person.java

package com.oracle.object.extend;

public class Person extends BuRuAnimal{
	
	String job;
	
	String jobAdress;
	
	void speak(){
		
		System.out.println("speak................");
	}

	
	public static void main(String[] args) {
		
		Person liSi = new Person();
		
		liSi.age = 21;
		liSi.name = "李四";
		liSi.sex = 0;
		
		System.out.println(liSi.name + "的年龄是" + liSi.age + "岁，性别是:" + (liSi.sex == 0 ? "男" : "女"));
		
		
		liSi.eat();
		
		liSi.sleep();
	}
}

从上边的代码中可看出，子类中不要再定义属性和行为，直接继承父类，便有了父类的属性和行为，注意：访问修饰符决定了是否可继承

4.多态

多态性是指允许相同或不同子类型的对象对同一消息作出不同响应

4.1 重载:同一个动作作用在同一个对象上拥有不同的解释 overload

重载又称静态多态，编译时多态

4.2 重写:同一个动作作用在不同的对象上拥有不同的解释 override

重写又称动态多态，运行时多态

狭义的多态指重写

多态(重写)的机制:

4.2.1 声明一个父类型的引用指向具体子类型的实例

Person p = new Student();

4.2.2 运行时才能绑定

Person p = new Student();
解释一下非运行时绑定：
Student s = new Student();

4.2.3 运行时可变

p = new Teacher();
p = new Junren();

举例说明：图形类包含矩形类，圆类，三角类（此时以等边三角形举例）
Shape.java

package com.tao.object.extend;

/**
 * 图形类
 * @author 天外飞星
 *
 */
public class Shape {

	public Shape(){
		
		
	}
	
	public Shape(int a){
		
		this.a = a;
		
	}
	
	public Shape(int a,int b){
		
		this.a = a;
		this.b = b;
		
	}
	
	protected int a;
	
	protected int b;
	
	/**
	 * 计算周长
	 * @return
	 */
	public double countZhouChang(){
		
		System.out.println("计算周长");
		
		return 0;
	}
	
	/**
	 * 计算面积
	 * @return
	 */
	public double countArea(){
		
		System.out.println("计算面积");
		
		return 0;
	}
	
}

Triangle.java

package com.tao.object.extend;

/**
 * 正三角形
 * @author 
 *
 */
public class Triangle extends Shape {

	
	public Triangle(){
		
		
	}
	
	public Triangle(int a){
		
		this.a = a;
		
	}
	
	//重写
	/**
	 * 计算当前三角形的面积
	 */
	public double countArea(){
		
		return Math.pow(3, 0.5) / 4 * Math.pow(a, 2);
	}
	//重写
	@Override
	public double countZhouChang() {
		// TODO Auto-generated method stub
		return 3*a;
	}
      //以下是重载的体现，都是求area但是，方法各不相同，即同一个动作作用在同一个对象上拥有不同的解释
	/**
	 * 计算边长为b的三角形的面积
	 */
	public double countArea(int b){
		
		return  Math.pow(3, 0.5) / 4 * Math.pow(b, 2);
	}
	
	/**
	 * 计算底为c，并且高为h的三角形的面积
	 */
	public double countArea(int c,int h){
		
		return  0.5 * c * h;
	}
	
	/**
	 * 计算边长为d，并且此边长与斜边的夹角为e的的三角形的面积
	 */
	public double countArea(int d,double e){
		
		
		return d / 2 * Math.sin(e) * d;
	}
	
	
	
	public static void main(String[] args) {
		
		Triangle triangle = new Triangle();
		
		triangle.a = 10;
		
		//triangle.countArea();
		
		//triangle.countZhouChang();
		
		
		/*double area = triangle.countArea();
		
		
		System.out.println(area);*/
		
		
		//double area = triangle.countArea(20);
		//System.out.println(area);
		
		//System.out.println(triangle.countArea(10, 8));
		
		System.out.println(triangle.countArea(10, Math.PI / 3));
		
	}
	
	
}

Rectangle .java

package com.tao.object.extend;

public class Rectangle extends Shape{

	public Rectangle(){
		
	}
	
	public Rectangle(int a,int b){
		
		this.a = a;
		this.b = b;
	}	
		
	}
	//重写
	@Override
	public double countZhouChang() {
		
		return 2*(a+b);
	}

	@Override
	public double countArea() {
		// TODO Auto-generated method stub
		return a*b;
	}
	
	
}

Ring.java

package com.tao.object.extend;

public class Ring extends Shape{

	
	public Ring(){
		
	}
	
	public Ring(int r){
		
		this.a = r;
	}

	@Override
	public double countZhouChang() {
		// TODO Auto-generated method stub
		return 2*Math.PI*a;
	}

	@Override
	public double countArea() {
		// TODO Auto-generated method stub
		return Math.PI*Math.pow(a,2);
	}
}

test.java

package com.tao.object.extend;

public class test {
	public static void main(String[] args) {
		//声明一个父类型的引用指向具体子类型的实例
		Shape shape=new Triangle(10);
		double zhouchang =shape.countZhouChang();
		System.out.println("三角形周长："+zhouchang);
		double area=shape.countArea();
		System.out.println("三角形面积："+area);
		//不用重新声明局部变量,体现了运行时可变
		shape=new Rectangle(10,20);
		zhouchang=shape.countZhouChang();
		area=shape.countArea();
		System.out.println("矩形周长："+zhouchang);
		System.out.println("矩形面积："+area);
	        //不用重新声明局部变量,体现了运行时可变
		shape=new Ring(10);
		zhouchang=shape.countZhouChang();
		area=shape.countArea();
		System.out.println("圆周长："+zhouchang);
		System.out.println("圆面积："+area);
	}
}

有惊喜哟~
在这里插入图片描述

关注公众号，随时学习最新内容，并与博主零距离交流！
在这里插入图片描述

旋律~学

关注

57
点赞
踩
207

收藏

觉得还不错? 一键收藏
打赏
2
评论
面向对象的四大特征（非常重要）

面向对象四大特征：抽象，封装，继承，多态（非常重要）1.抽象定义：抽象是将一类对象的共同特征总结出来构造类的过程,包括数据抽象和行为抽象两方面,抽象只关注对象的哪些属性和行为,并不关注这此行为的细节是什么1.1 研究事物的静态特征(属性)1.2 研究事物的动态特征(方法/函数)1.3 形成结果(类,class)1.4 类和对象相互转变(new)举例说明：学生有姓名，有年龄，有身份证...
复制链接

扫一扫