java面向对象编程（oop）

java面向对象编程（oop）

面向对象编程：是一种以对象为原子性的编程思想，每个对象之间相互联系构建了整个系统、

面向对象的本质就是以类组织代码，以对象封装数据。

面向过程编程：是一种注重编程过程的思想，他关注一个对象本身的具体实现过程，而不会注重对象和对象的联系

就好比我们身体的最小单位是细胞，每个细胞就相当于对象。面向对象关注的是这些细胞如何组织才能成为一个器官(成为一个系统)。而面向过程关注的某一个细胞是有什么构成的。

对象和类的关系

类是对象的抽象，对象的类的实例化

比如:我们所有个体都称之为人类，而每个人都是单独不同的个体，人就是个体的抽象，并没有人这个东西，只能有小明这个个体存在。而每一个个体都属于人，对象又是类的实例化。反过来说，无数多个对象集合在一起，我们称这个集合为类。

对象的构成

对象由属性和方法构成。

属性：本身具有的我们称之为属性。比如：小明身高170cm，体重60kg，这些都是小明本身具有的。

方法：我们可称之为行为和动作，方法包括一系列的动作和返回系列的值。如：小明吃饭，吃饱没。跑步，跑完没等

对象的创建

new 对象名(); 创建了一个对象

//如：
new Student();

对象的命名

对象创建好了，必须为每一个对象命名，加以区分。就好比新婴儿必须起个名字来区别。

对象名 名字=new 对象名()

Student xiaoming=new Student();
//这样一个名为小明对象创建完成

对象调用类的属性和方法

对象.属性名调用属性

对象.方法名调用方法

构造器

构造器的定义：

1. 必须名字和类名相同
2. 没有返回值，也没有void。
3. 修饰符+名字（必须是类名）(){};

构造器的作用：

1. new对象时，本质是在调用构造器。在一个类中，如果创建没有构造器，类本身会有一个隐藏的构造器。
2. 初始化对象的值

注意：

1. 如果定义了一个有参参数构造器，那么就必须显示定义一个无参构造器。（在new的对象没有参数的情况下）

4种权限修饰符

• public（公共的）所有类能够访问
• protected（受保护的）同一个包下，和子类能够访问
• default（缺省的，不需要写这个修饰符）同一个包下能够访问
• private（私有的）只有类内部能够访问
• 

面向对象三大特性（封装，继承，多态）

封装

禁止对象直接访问类中的数据，因通过接口来访问（get得到，set设置），这称为数据封装。

通俗说，属性私有（用private修饰），get，set方法

封装的作用：

1. 提高程序的安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 增加系统的可维护性

继承

一个类可以调用另一个类的公共的方法和属性，我们称这种关系为继承。

用extends表示两个类之间的继承关系，继承的这个类称为子类，被继承的类称为父类。父类是所以子类公共的部分，而子类是对父类的延展。所以用extends（意思为延展）这个英文单词来表示继承关系。

所有的类都继承一个根类object，它是默认继承的。（就好比我们所有人类都继承了远古猿祖先的基因，它是所有类的地基）

在ieda中，ctrl+h查看当前类的关系。

super和this关键字

1. super必须在继承父类的时候才能使用（在子类中使用），它的作用是调用父类的方法的构造器。
2. 子类构造器会自动调用父类的构造器（默认的super();）,如果写出来，必须在构造器的第一行
3. super和this不能同时调用构造方法，只能存在一个。

super和this的区别

1. 代表的对象不同：super代表的是父类这个对象，this代表的是本身这个对象
2. 使用前提不同：super必须在继承的条件下使用，没有继承也可以使用
3. 如何调用构造方法？
   1. 用this(); 代表调用本类构造方法
   2. 用super(); 代表调用父类构造方法
   3. 在main方法中，通过new对象来调用类中的构造方法

重写（覆盖）

子类对父类的方法进行重新改写

要求：

1. 被重写的方法必须和父类方法的名字和参数类型相同，且只能重写方法的语句块。
2. 重写后的方法权限修饰符必须比父类的方法修饰符权限更大（更公开），或者相同。
3. 重写的方法必须和被重写的方法（也就是父类的方法）都是静态的（用static修饰的），或都是非静态的。
4. 重写的子类方法抛出的异常，不能大于父类（被重写）方法的异常

ctrl+o快速重写父类方法

为什么需要重写呢?

1. 因为父类有时提供的方法，不能满足我们的需求，或超出我们的需求，所以要有重写这个功能，来对父类的方法进行重写，来满足我们的需要。

多态

多态实现的三个必要条件

1. 必须要有继承关系
2. 必须要有重写
3. 父类引用变量指向子类对象

​ 多态定义和使用：

​ 父类名 变量名=new 子类对象名();

Student student=new Student();
//可以调用子类的方法和父类的方法

Person person=new Student();//多态的使用
//父类型可以指向子类型，但是不能调用子类型独有的方法
//但可以通过强制转换进行转换

多态的方法的多态，没有属性多态一说

什么是多态：多态是同一个行为有多种表达形式（多种形态）

对象能执行那些方法，主要看new左边的类型。

instanceof关键字

这个关键字instanceof的作用是：通过instanceof来判断对象和类之间是否有关系。

使用语法：x instanceof y （x为对象名称，y为类名字）

//instanceof关键字判断对象（左边）是否属于（右边）类或子类，如果是返回turn，否则返回false

对象的转化

类的对象的转化和数据类型的转化大致相同，低转高为自动转化，高转低需要强制转化

Person1 student32 = new Student3();//student32为person1类的对象，指向Student3子类。可把student32对象，转化为Student3类对象。
//高转低需要强制转化，和数据类型转化格式一样
((Student3)student32).go();//第一种方法，即可调用Student3类里的方法
                                    
//第二种方法
Student3 A=(Student3)student32;// 先进行强制转化，然后把值赋给一个为Student3类A对象
A.go();
A.go1();

static和final关键字

被static修饰的方法和属性称为静态方法属性，**可以通过类名.方法名（或类名.属性名）进行调用。**没有则通过new对象，在通过对象名.方法（对象名.属性）调用

static{
 //这是静态代码块，随着类的加载只执行一次
}

被final修饰的类不能被继承

被final修饰的方法不能被子类重写

被final修饰的变量不能被改变，值只能赋一次

抽象类

抽象类顾名思义是把类更加抽象，它像一个框架，不去实现里面的细节，通过继承它的子类来对他的方法进行实现。

让abstract修饰的类称为抽象类。

抽象类不能被实例化。

抽象类中可以没有抽象方法，但是有抽象方法的类必须是抽象类。

子类继承抽象类，必须实现（重写）抽象类中的所以方法。既对抽象类里面细节的实现。

抽象类继承抽象类，则不需要。

抽象类里可以有具体实现，也可以有抽象规范

接口

接口是抽象类的更加抽象，它是一种规范，没有具体细节的实现。通过规范让不同的人不同的实现方式。

通过interface关键字定义接口，接口只能有方法的规范，没有具体实现。接口的方法默认是公共的，抽象的

public abstract   void add();
//实际写方法可省略public abstract
void add();

public static final int a=10;
//实际写属性可省略 public static final
int a=10;

接口不能被实例化，因为接口中没有构造方法。

普通类通过interface关键字来实现接口，通过，（逗号）可以实现多个接口，实现接口必须实现接口的方法

n种内部类

在一个类中含有另一个类，如a类含有b类，我们称b为内部类，a为外部类

1. 成员内部类（一个类中有另一个类）

2. public class Person2 {
   
    public class Person3 {
   
    }
     }
   

3. 静态内部类（用static修饰的内部类）

4. ```java
public class Person2 {

    public static class Person3 {

    }
}

5. 局部内部类（在方法里面定义的类）

6. public class Person2 {
    public void add(){
        class Person3{
   
        }
    }
   

}

7. 匿名内部类

一个java类中可以有多个class类，但只能有一个public class类

以后会慢慢补充不足.