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

姚思瀚

2026-06-18 • 👁 2人浏览过

面向对象四大特征：抽象，封装，继承，多态（非常重要） 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);
}
}

有惊喜哟~

关注公众号，随时学习最新内容，并与博主零距离交流！

相关文章