Java基础-----面向对象

面向对象（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的对象