面向对象总结_对客观事物进行抽象的过程中,面向对象方法更加强调关注事物的-CSDN博客

本文链接：https://blog.csdn.net/weixin_45739322/article/details/102685836

文章目录

什么是面向对象？

什么是面向对象？

面向对象：将现实生活中的事物，封装成对象，通过对象的实例化和调用，完成需求。
面向对象，关注点是对象的属性和方法，而忽略事物执行的顺序或过程。
面向过程：将现实生活中的事物，按照发生的顺序使用代码顺序执行。
面向过程，关注事物执行的顺序。

面向对象的特征：1、抽象 2、封装 3、继承 4 、多态

抽象

抽象：抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。

抽象：将现实中的事物，抽取出外部特征和方法。使用类来表示。
抽象的步骤：
在这里插入图片描述

封装

继承：继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。
关键字：private
隐藏类的内部细节，提供外部访问的接口。叫做封装。封装使用get ，set方法。

this: 表示当前对象。

类中拥有构造方法。构造方法是用来构建对象。
构造方法是：方法名称与类名相同，无返回值的方法。

默认一个类中，有一个无参构造方法。不写也有。
当手动提供了一个有参构造方法。系统将不再提供无参构造方法。
：将 name 和 age 属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问，任何要访问类中私有成员变量的类都要通过这些getter和setter方法。：将 name 和 age 属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问，任何要访问类中私有成员变量的类都要通过这些getter和setter方法。在这里插入图片描述
将 name 和 age 属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问，任何要访问类中私有成员变量的类都要通过这些get和set方法。

继承

什么是继承：子类可以继承父类共有的属性和方法。继承关键字是：extends
子类不能继承父类的构造方法。也就是说super()不是继承，是调用。
继承的优点：实现类的重用，减少代码的冗余。

子类继承了父类后：
子类可以访问父类中的公有的属性，对象可以直接访问父类的属性
[子类可以访问父类中的方法]。对象可以直接访问父类的方法。
子类可以重写父类中的方法。
通过一个例子来说一下继承的优点吧，如下：

父类：
public class People {
private String name;
private int age;
private String id;
private String sex;

public String getName() {
	return name;
}

public void setName(String name) {
	this.name = name;
}

public int getAge() {
	return age;
}

public void setAge(int age) {
	this.age = age;
}

public String getId() {
	return id;
}

public void setId(String id) {
	this.id = id;
}

public String getSex() {
	return sex;
}

public void setSex(String sex) {
	this.sex = sex;
}

public People() {
}

public People(String name, int age, String id, String sex) {
	this.name = name;
	this.age = age;
	this.id = id;
	this.sex = sex;
}

}

子类:
public class Student extends People {

private String stuNo;

// 子类构造方法  无参
public Student(){
	super();
	System.out.println("学生类的无参构造方法被调用");
}

public Student(String name){
	//this();  调用当前的构造方法
	//super(); 调用父类的构造方法
} 
//有参构造方法
public Student(String name, int age, String id, String sex,String stuNo){
	super(name, age, id, sex); //调用父类中的构造方法
	this.stuNo = stuNo;
}
//this super 各自的用法
public void show(){
	System.out.println(this.stuNo);
	System.out.println(super.getName());
}

}

测试类：
public class Test {
public static void main(String[] args){
People people = new People();

	Student student = new Student("张三",18,"1001","女","1001");
	
	System.out.println(student. getName());

子类就具有父类当中的属性和方法，子类就不会存在重复的代码，维护性也提高，代码也更加简洁，提高代码的复用性（复用性主要是可以多次使用，不用再多次写同样的代码）继承之后的代码：

多态

一种类型，多种形态，对象在创建时是父类形态，在使用时是子类形态。
多态在程序设计中，为程序提供了 [可插拔性]**

向上转型：子类赋值给父类。自动类型转换。
向下转型：父类强制转换成子类，需要加子类类型符号。

多态：形成的必要因素：
1：必须有继承关系。
2：子类中需有方法的重写。
关键词：instanceof : 是否包含子类对象。

演示

多态的演示。
@author hadoop
*/
public class Test {

public static void main(String[] args) {
	// 初始化对象
    Penguin penguin = new Penguin("qq",2,85,50,"雌");
	
	Dog dog = new Dog("大黄",3,75,85,"黄色");
	
	
	// 多态 一种类型，多种形态。
	Pet pet = new Penguin("qq",2,85,50,"雌");// 你记得，子类赋值给父类。自动类型转换。向上转型。
	    pet = new Dog("大黄",3,75,85,"黄色");  // 你记得，子类赋值给父类。自动类型转换。向上转型。
	    
	    pet.eat();// 多态的父类，拥有子类的多种形态，子类重写父类的方法。父类对象在调用方法时，运行子类的方法。
	    
	    
	if(pet instanceof Penguin){
		Penguin pen = (Penguin)pet;// 你记得，父类强制转换成子类，需要加子类类型符号，向下转型。
		pen.eat();
	}else if(pet instanceof Dog){
		Dog dog2 = (Dog)pet;
		dog2.eat();
	}	
}