Java基础-----面向对象-优快云博客

本文链接：https://blog.youkuaiyun.com/u013021928/article/details/47261659

面向对象（OOP）是一种程序的设计方法，或者说一种设计的范型，它的基本思想是使用对象，类，继承，封装等概念来进行程序的设计，面向对象的3个只要特征：封装、继承、多态

对象与类:

类是对同一种事物的描述，比如说人就可以说是一个类，但是他并没有指明一个具体的人，而是很抽象的描述了一个范围，而某一个具体的人，比如说一个叫姚明的人就是一个具体的对象，再举个例子，比如说猫类，一只叫Tom的猫就是该猫类的具体对象,总的来说就是类是用来描述一个对象的。

java中用过class关键字来声明一个类,通过new关键字+类名()来创建一个对象，在类中可以定义该类的属性和行为。

属性：对应类中的成员变量。

行为：对应类中的成员函数。

构造函数：

构造函数是一个没有返回值的，并且与类名相同的函数，一个类必须有构造函数，如果不手动定义，则系统会自动生成一个默认的无参的构造函数，如果手动定义了构造函数，那系统默认的构造函数则不会生成，多个构造函数，是以重载的形式出现的，当一个对象创建的时间，会自动调用其对应的构造函数。

示例代码：

public class Test {
	
	//如果程序员没有定义构造函数，则系统会自动生成一个默认的无参构造函数
	

}

public class Test {
	
	
	//如果程序员定义了构造函数，则系统不会再生成默认的无参构造函数
	public Test(String str){
		
	}
	
	//构造函数是以函数重载的形式存在的
	public Test(String str,String str1){
		
	}
	

}

成员变量、局部变量、静态变量:

成员变量在整个类中都能被访问，且成员变量有默认的初始化值，成员变量的生命周期随着对象的创建而创建，随着对象的销毁而销毁，他存在与对象所在的对内存中,访问方式是通过对象名.变量名的形式。

局部变量的作用域是在一个局部范围中比如for循环，if判断，静态与非静态的代码块或者是某个函数中，并且如果语句或者函数运行结束，局部变量也跟着销毁，局部变量只有在当前代码块或者函数中才能被访问，他存放在栈内存中，没有默认的初始化值。

静态变量由static修饰符修饰，属于类的，随着类的加载而加载，访问的方式是通过类名.变量名的形式

示例代码：

public class Test {

	public static void main(String[] agrs) {
		Test1 test1 = new Test1();
		// 成员变量,通过对象访问
		test1.name = "test";
		// 静态变量，通过类名访问
		Test1.clazz="test";
	}

}

class Test1 {
	// 成员变量,用过对象访问
	public String name;

	// 静态变量,通过类名访问
	public static String clazz;

	public void show() {
		// 局部变量,只能在当前方法中被访问
		int age = 0;
                age=20;
        }
}

this和super关键字 :

this关键字代表是对当前本类对象的引用,当成员变量与局部变量重名时可以通过this关键字来区分

super关键字可以调用父类的指定方法

示例代码：

this关键字的使用：

	private String name;
	public Test(String name){
		//this.name表的是当前类对象的成员变量name
		this.name=name;
	}

super关键字的使用：

public class Test {

	public Test(){
	}
	public void show(){
	}
}

class Test1 extends Test {
	
	public Test1(){
		//调用父类的无参构造函数
		super();
		//调用父类的show()方法
		super.show();
	}
}

面向对象的三大特性：封装、继承、多态

封装:

封装的目的是要实现软件内部的“高内聚、低耦合”,隐藏对象的属性和实现细节，仅对外提供公共访问方式。

对象是封装最基本的单位，封装就是把描述一个对象的属性和行为的代码封装在一个模块中，属性用变量定义，行为用方法定义，封装的基本原则就是，把对同一个事物进行操作的方法和相关的数据放在同一个类中。

比如：

发动汽车、打开车门、打开车窗，车轮，车身，车门，这些行为和动作，就可以封装到同一个类中，在个类中有发动汽车，打开车门，打开车窗的方法，有车的品牌，价格，最高速度这些属性，在操作的时候，通过这个类的实例对象来经行操作，车的实例对象发动汽车，车的实例对象打开车门等，示例代码：

public class Car {
	
	//品牌
	private String brand;

	//价格
	private int price;
	
	//最高速度
	public static int MAX_SPEED=200;

	public String getBrand() {
		return brand;
	}

	public void setBrand(String brand) {
		this.brand = brand;
	}

	public int getPrice() {
		return price;
	}

	public void setPrice(int price) {
		this.price = price;
	}
	
	//打开车门方法
	public void openDool(){
		System.out.println("打开车门");
	}
	
	//开打车窗
	public void openWindows(){
		System.out.println("打开车窗");
	}
	
	//发动汽车
	public void run(){
		System.out.println("启动汽车");
	}
	
	
}

继承:

继承是类与类之前关系，例如A继承B，那么就可以说A是B的子类，B是A的父类，并且子类可以自动共享父类的数据和方法，继承的出现，提高了类的可重用性和扩展性，示例代码：

//Person类
class Person{
	//姓名
	private String name;
	//性别
	private String sex;
	//年龄
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	public void say(){
		System.out.println("说话");
	}
	
}
//Student类继承自Person类
class Student extends Person{
	//班级
	private String classroom;

	public String getClassroom() {
		return classroom;
	}

	public void setClassroom(String classroom) {
		this.classroom = classroom;
	}
	
}

Student类继承自Person类，及自动共享了Person类public和protected修饰的属性和方法，在Student对象初始化的时候，会首先在内存中创建一个父类对象，然在父类对象的外部加上子类的特有属性和方法，两者合在一起形成了一个子类对象。

多态:

多态是指，父类引用了其子类的对象，示例代码：

	public static void main(){
             //父类引用了子类的对象
             Person p=new Student();
	}

类型为Person的变量p,指向的是其子类Student的对象