面向对象详解

面向过程&&面向对象

语言的进化发展跟生物的进化发展其实是一回事，都是“物以类聚”。相近的感光细胞聚到一起变成了我们的眼睛，相近的嗅觉细胞聚到一起变成了我们的鼻子。

语句多了，我们将完成同样功能的相近语句，聚到了一块儿，便于我们使用。于是，方法出现了。

变量多了，我们将功能相近的变量组在一起，聚到一起归类，便于我们调用。于是，结构体出现了。

方法多了，变量多了，结构体不够用了，我们就将功能相近的变量和方法聚到一起，于是类和对象出现了。

寥寥数语，就深刻的展示了语言的进化历史。其实都非常自然，“物以类聚”。

企业的发展也是“物以类聚”的过程，完成市场推广的人员聚到一起形成了市场部。完成技术开发的人员聚到了一起形成了开发部。

面向过程的思维模式

面向对象的思维模式是简单的线性思维，思考问题首先陷入第一步干什么、第二步做什么细节中。这种思维模式适合处理简单的事情。

如果面对复杂的事情，这种思维模式会陷入令人发疯的状态。比如：如何造火箭。

面向对象的思维模式

面向对象的思维模式说白了就是分类思维模式。思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的世界进行面向过程的思索。

这样就可以形成很好的协作分工。比如：设计师分了10个类，然后将10个类交给了10个人分别进行详细设计和编码。

显然，面向对象适合处理复杂的问题，适合处理需要多个协作的问题。

如果一个问题需要多个人协作一起解决，那么你一定要用面向对象的方式来思考。

对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

OOP详解

1、什么是面向对象

Java的编程语言是面向对象的，采用这种语言进行编程称为面向对象编程（Object-Oriented Programming,OOP）

面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据。

抽象（abstract）

1. 忽略一个主题中与当前目标无关的那些方面，以便更充分的注意与当前目标有关的方面。抽象并不打算了解全部问题，而是选择其中的一部分，暂时不用关注细节。
2. 例如：要设计一个学生管理系统，那么对于学生，只关心他的班级、学号、成绩等，而不用去关心他的身高、体重这些信息。抽象是什么？就是将多个物体公共点归纳出来，抽出像的部分。

封装（Encapsulation）

封装是面向对象的特征之一，是对象和类概念的主要特性。封装是把过程和数据包围起来，对数据的访问只能通过制定的方式。

在定义一个对象的特性的时候，有必要决定这些特性的可见性，即那些特性对外部是可见的，哪些特性用于表示内部状态。

通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称之为隐藏信息。

信息隐藏是用户对封装性的认识，封装则为信息隐藏提供支持。

封装保证了模块具有较好的独立性，使用程序维护修改较为容易。对应用程序的修改仅限于类的内部，因而可以将应用程序修改带来的影响减少到最低限度。

继承（inheritance）

1. 继承是一种联结类的层次模型，并且允许和支持类的重用，它提供了一种明确表述共性的方法。
2. 新类继承了原始类后，心累就继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）
3. 派生类（子类）可以从它的基类（父类）那里继承方法和实例变量，并且派生类（子类）中可以修改或增加新的方法使之更合适特殊的需要，继承性很好的解决了软件的可重用性问题。比如说：所有的windows应用程序都有一个窗口，它们可以看做都是一个窗口类派生出来的。但是有的应用程序用于文字处理，有的应用程序用于绘图，这是由于派生出了不同的子类，各个子类添加了不同的特性。

多态（polymorphism）

多态性是指允许不同类的对象对同一消息作为响应。

多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

相同类域的不同对象，调用相同方法，表现出不同的结果

从认识论角度考虑是先有对象后有类。对象是具体的事物。类是抽象的，是对对象的抽象。

从代码运行角度考虑是现有类后有对象。类是对象的模板。

2、类与对象的关系

类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。

例如：我们生活中所说的词语：动物、植物、手机、电脑等等。这些也都是抽象的概念，而不是指的摸一个具体的东西。

列如：Person类，Pet类，Car类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为

对象是抽象概念的具体实例

例如：张三就是人的一个具体实例，张三家的旺财就是狗的一个具体实例。能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。

示例

1 Student s = new Student(1L,"tom",20); 
2 s.study(); 
3 
4 
5 Car c = new Car(1,"BWM",500000); 
6 c.run();

对象s就是student类的一个实例，对象c就是Car类的一个具体实例，能够使用的是具体实例，而不是类。

类知识给对象的创建提供了一个参考的模板而已

但是在Java中，没有类就没有对象，然而类有是根据具体的功能需求进行实际的分析，最终抽象出来的。

3、对象和引用的关系

引用"指向"对象

使用类类型、数组类型、接口类型声明出的变量，都可以指向对象，这种变量就是引用类型变量，简称引用。

在程序中，创建出对象后，直接使用并不方便，所以一般会用一个引用类型的变量去接收这个对象，这个就是所说的引用指向对象。

总结：对象和引用的关系，就如电视机和遥控器，风筝和先的关系一样。

方法回顾与加深

方法一定是定义在类中，属于类的成员

1、方法的定义

格式：   修饰符   返回值类型    方法名（参数列表）异常抛出类型{......}

1. 修饰符

public、static、abstract、final等等都是修饰符，一个方法可以有多个修饰符。例如程序入口main方法，就使用了public static这个两个修饰符

注：如果一个方法或者属性有多个修饰符，这多个修饰符是没有先后顺序的

2. 返回类型

方法执行完如果有要返回的数据，那么就要声明返回数据的类型，如果没有返回的数据，那么返回类型就必须写void

只有构造方法（构造器）不写任何返回类型也不写void

 1 public String sayHello(){ 
 2     return "hello"; 
 3 }
 4 
 5 
 6 public int max(int a,int b){ 
 7     return a>b?a:b; 
 8 }
 9 
10 
11 public void print(String msg){ 
12     System.out.println(msg); 
13 }

思考：声明返回类型的方法中一定要出现return语句，那么没有返回类型（void）的方法中，能不能出现return语句？

注：break和return的区别

return语句的作用

1. return从当前的方法中退出，返回到该调用的方法的语句处，进行执行。
2. return返回一个值给调用该方法的语句，返回值的数据类型必须与方法的声明中的返回值的类型一致。
3. return后面也可以不带参数，不带参数就是返回空，其实主要目的就是用于向终端函数执行，返回调用函数处。

break语句的作用

1. break在循环体内，强行结束循环的执行，也就是结束整个循环过程，不在判断执行循环的条件是否成立，直接转向循环语句下面的语句。
2. 当break出现在循环体重的switch语句体内时，其作用只是跳出该switch语句体。

3. 方法名

遵行java中标示父的命名规则即可

4.参数列表

根据需求定义，方法可以是无参的，也可以有一个参数，也可以有多个参数。

5.异常抛出类型

如果方法中的代码在执行过程中，可能会出现一些异常情况，那么就可以在方法上把这些异常声明并抛出，也可以同时声明抛出多个异常，使用逗号隔开即可。

【示例】

1 public void readFile(String file)throws IOException{ 
2 
3 }
4 
5 public void readFile(String file)throws IOException,ClassNotFoundException{
6 
7 }

2、方法调用

在类中定义了方法，这个方法中的代码并不会执行，当这个方法被调用的时候，方法中的代码才会被一行一行顺序执行。

1、非静态方法

没有使用static修饰符修饰符方法，就是非静态方法

调用这种方法的时候，是“一定”要使用对象的。因为非静态方法时属于对象的（非静态属性也是一样的）

1 public class Student {
2     private double score=10.0d;
3     public static void main(String[] args) {
4         //对象
5         Student s = new Student();
6         //非静态变量使用对象来访问
7         System.out.println(s.score);
8     }
9 }

2、静态方法

使用static修饰符修饰的方法，就是静态方法。

调用这种方法的时候，可以使用对象调用，也可以使用类来调用，但是推荐使用类进行调用，因为静态方法是属于类的（静态属性也是一样）

 1 public class Student {
 2     private static int age=10;
 3     public static void main(String[] args) {
 4         //对象
 5         Student s = new Student();
 6         //静态变量可以使用类名
 7         System.out.println(Student.age);
 8         System.out.println(s.age);
 9     }
10 }

3、类中方法之间的调用

假设同一个类中有两个方法，a方法,b方法，a.b都是非静态方法，相互之间可以直接调用

1 public void a(){
2    b();  
3 }
4 public void b(){
5 
6 }

a和b都是静态方法，相互之间可以直接调用

1 public static void a(){ 
2     b(); 
3 }
4 public static void b(){ 
5 
6 }

a静态方法，b是非静态方法，a方法中不能直接调用b方法，但是b方法中可以直接调用a方法。静态方法不能调用非静态方法。

1 public static void a(){ 
2     //b();报错 
3 }
4 public void b(){ 
5     a(); 
6 }

另外：在同一个类中，静态方法内不能直接访问到类中的非静态属性。

总结：类中方法中的调用，两个方法都是静态或者非静态都可以互相调用，当一个方法时静态，一个方法时非静态的时候，非静态方法可以调用静态方法，反之不能

3、调用方法时的传参

1.形参和实参

1 public void test(int a){
2 
3 }
4 main:
5 int x = 1;
6 t.test(x);

参数列表中的a是方法test的形参（形式上的参数）

调用方法时的x是方法test的实参（实际上的参数）

注意：形参的名字和实参的名字都只是一个变量的名字，是可以随便写的，我们并不关心这个名字，而是关心变量的类型以及变量接收的值。

2、值传递和引用传递

调用方法进行传参时，分为值传递和引用传递两种

如果参数的类型是基本类型，那么就是值传递

如果参数的类型是引用类型，那么就是引用传递

值传递是实参把自己变量本身存的简单数值赋值给形参。

引用传递是实参把自己变量本身存的对象内存地址赋值给形参。

所以值传递和引用传递本质上是一回事，只不过传递的东西的意义不同而已

【值传递】

 1 public class Test {
 2     public static void changeNum(int a) {
 3         a = 10;
 4     }
 5 
 6     public static void main(String[] args) {
 7         int a = 1;
 8         System.out.println("before: a = " + a); //1
 9         changeNum(a);
10         System.out.println("after: a = "+a); //1
11     }
12 }

【引用传递】

 1 public class Test {
 2     public static void changName(Student student){
 3         student.name="dz";
 4     }
 5 
 6     public static void main(String[] args) {
 7         Student student = new Student();
 8         System.out.println("before name="+student.name);//before name=null
 9         changName(student);
10         System.out.println("after name="+student.name);//after name=dz
11     }
12 }
13 class Student{
14     String name;
15 }

4、this关键字

在类中，可以使用this关键字表示一些特殊的作用

1.this在类中的作用

【区分成员变量和局部变量】

1 public class student{
2   private String name;
3   public void setName(String name){
4       //this.name表示类中的属性name
5       this.name = name;        
6 }    
7 }

【调用类中的其他方法】

 1 public class Student{ 
 2     private String name; 
 3     public void setName(String name){ 
 4            this.name = name; 
 5     }
 6     public void print(){ 
 7           //表示调用当前类中的setName方法 
 8           this.setName("tom"); 
 9     } 
10 }

注：默认情况下，setName("tom")和this.setName("tom")的效果是一样的

【调用类中其他构造器】

 1 public class Student{
 2   private String name;
 3   public Student(){
 4       //调用一个参数的构造器，并且参数的类型是string
 5       this("tom");  
 6     }
 7    public Student(String name){
 8          this.name = name;  
 9     }      
10 }

注：this的这种用法，只能在构造器中使用。普通的方法时不能用的。并且这句调用的代码只能出现在构造器中的第一句。

【示例】

 1 public class Student{
 2    private String name;
 3   public Student(){
 4        System.out.println("Hello"); 
 5       //编译报错，因为this("tom")不是构造器中的第一句
 6        this("tom");  
 7      }
 8    public Student(String name){
 9           this.name = name;  
10      }      
11  }

2、this关键字在类中的意义

this在类中表示当前类将创建出的对象

【示例】

 1 public class Student {
 2         private String name;
 3 
 4         public Student() {
 5             System.out.println("this = " + this);
 6         }
 7 
 8         public static void main(String[] args) {
 9             Student s = new Student();
10             System.out.println("s = " + s);
11         }
12     }

运行看结果：

 this和s打印的结果是一样的，那么其实也就是变量s是从对象的外部执行对象，而this是在对象的内部执行对象本身。

这样就能理解为什么this.name代表的是成员变量，this.setName("tom")代表的是调用成员方法，因为这两句代码从本质上讲，和在对象外部使用变量s来调用是一样的。

【this和s打印出来的内存地址是一样的，使用==比较的结果为true】

 1 public class Student {
 2     public Student getStudent() {
 3         return this;
 4     }
 5 
 6     public static void main(String[] args) {
 7         Student s1 = new Student();
 8         Student s2 = s1.getStudent();
 9         System.out.println(s1 == s2);//true
10     }
11 }

【类中的this是和s1相等还是和s2相等呢？】

 1 public class Student {
 2     private String name;
 3     public void test(){
 4         System.out.println(this);
 5     }
 6 
 7     public static void main(String[] args) {
 8         Student s1 = new Student();
 9         Student s2 = new Student();
10         s1.test();
11         s2.test();
12     }
13 }

注：这句话是要这么来描述的，s1对象中的this和是相等，s2对象中的this和s2相等，因为类是模板，模板中写的this并不是只有一个，每个对象中都有一个属于自己的this，就是每个对象中都有一个属于自己的name属性一样。

创建与初始化对象

使用new关键字创建对象

使用new关键字创建时，除了分配内存空间之外，还会给创建好的对象进行默认初始化以及对类中构造器的调用

1 public class Student{
2   private String name;
3   public Student(){
4      name = "tom";  
5     }    
6 }

1 public class Student{
2   private String name;
3   public Student{
4      name = "tom";      
5     }
6   public Student(String name){
7     this.name = name;    
8   }      
9 }

1 public class Student {
2     private String name;
3     public Student(){
4         this();
5     }
6     public Student(String name){
7         this.name = name;
8     }
9 }

默认构造器

在Java中，即使我们在编写类的时候没有写构造器，那么在编译之后也会自动的添加一个无参构造器，这个无参构造器也被称为默认构造器

【示例】

1 public class Student{
2 
3 }
4 
5 main:
6 //编译通过，因为有无参构造器
7 Student s = new Student();

但是，如果我们手动的编写了一个构造器，那么编译后就不会添加任何构造器了

【示例】

 1 public class Student{
 2   private String name;
 3   public Student(String name){
 4        this.name = name;
 5   }  
 6 }
 7 
 8 
 9 main:
10 //编译错误，因为没有无参构造器
11 Student s = new Student();

 内存分析

Java程序运行的内存分析

栈 stack：

1. 每个线程私有，不能实现线程间的共享
2. 局部变量放置于栈中。
3. 栈是由系统自动分配，速度快，栈是一个连续的内存空间

堆 heap:

1. 放置new出来的对象
2. 堆是一个不连续的内存空间，分配灵活，速度慢

方法区（也是堆）

1. 被所有线程共享
2. 用来存放程序中永远是不变或唯一的内容。（类代码信息、静态变量、字符串常量）

 引用类型的概念

1. java中，除了基本数据类型之外的其他类型称之为引用类型。
2. java中的对象是通过引用来操作的。（引用：reference）引用指的就是对象的地址

属性（field或者叫成员变量）

1. 属性用于定义该类或该类对象包含的数据或者说静态属性
2. 属性作用范围是整个类体
3. 属性的默认初始化   
4. 在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。（数值：0,0.0    char:u0000    boolean:false    所有引用类型：null）
5. 属性定义格式       【修饰符】    属性类型     属性名   =     【默认值】

类的方法

方法是类和对象动态行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序有一个个函数调用组成；

在面向对象中，整个程序的基本单位是类，方法是从属于类或对象的。

方法定义格式：

1 【修饰符】   方法返回值类型   方法名（形参列表）{
2 
3   //语句  
4 }

java对象的创建和使用

• 必须使用new关键字创建对象        Person person = new Person();
• 使用对象（引用）.成员变量来引用对象的成员变量     person.age
• 使用对象（引用）.方法（参数列表）来调用对象的方法   setAge(23)

类中就是：静态的数据   动态的行为

封装

我们看电视，只需要按一下开关和换台就可以了，没有必要了解电视的内部结构。

制造厂家为了方便我们使用电视，把复杂的内部细节全部封装起来，只给我们暴露简单的接口，比如：电源开关

需要让用户知道的暴露出来，不需要让用户了解的全部隐藏，这就是封装

专业解释：我们程序设置要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉，低耦合：仅暴露少量的方法给外部使用

1.封装的步骤

1. 使用private修饰需要封装的成员变量
2. 提供一个公共的方法设置或者访问私有属性     
3. 设置通过set方法，命名格式：set属性名（）；属性的首字母要大写
4. 访问通过get方法，命名格式：get属性名（）；属性的首字母要大写

 1 public class Student{
 2   public String name;
 3   public void println(){
 4      System.out.println(this.name);  
 5     }    
 6 }
 7 public class Test{
 8   public static void main(String[] args){
 9      Student s = new Student();
10      s.name = "tom";      
11   }  
12 }

在类中一般不会把数据直接暴露在外部，而使用private(私有)关键字把数据隐藏起来

【演示】

 1 public class Student{
 2   private String name;  
 3 }
 4 public class Test{
 5   public static void main(String[] args){
 6       Student s = new Student();
 7        //编译报错，在类的外部不能直接访问类中的私有成员
 8       s.name = "tom";      
 9     }  
10 }

如果在类的外部需要访问这些私有属性，那么可以在类中提供对于的get和set方法，以便让用户在类的外部可以间接的访问到私有属性

 1 //set负责给属性赋值
 2 //get负责返回属性的值
 3 public class Student{
 4   private String name;
 5   public void setName(String name){
 6       this.name = name;  
 7     }  
 8   public String getName(){
 9      return this.name;  
10     }  
11 }
12 
13 public class Test{
14   public static void main(String[] args){
15      Student s = new Student();
16      s.setName("tom');
17      System.out.println(s.getName());    
18     }  
19 }

2.作用和意义

1. 提高程序的安全性，保护数据
2. 隐藏代码的实现细节
3. 统一用户的调用接口
4. 提高系统的可维护性
5. 便于调用者使用

良好的封装，便于修改内部代码，提高可维护性

良好的封装，可以进行数据完整性检测，保证数据的有效性

3.方法重载

类中有多个方法，有着相同的方法名,但是方法的参数各不相同，这种情况被称为方法的重载。方法的重载可以提供方法调用的灵活性。

思考：HelloWorld中的System.out.println()方法，为什么可以把不同类型的参数传给这个方法？

方法重载必须满足以下条件

1. 方法名必须项目
2. 参数列表必须不同（参数的类型，个数，顺序的不同）
3. 方法的返回值可以不同，也可以相同

1 public void test(Strig str){} 
2 public void test(int a){} 
3 
4 public void test(Strig str,double d){} 
5 public void test(Strig str){} 
6 
7 public void test(Strig str,double d){} 
8 public void test(double d,Strig str){}

在Java中，判断一个类中的两个方法是否相同，主要参考两个方面：方法名字和参数列表

继承

现实世界中的继承无处不在。比如：

动物：哺乳动物，爬行动物

哺乳动物：灵长目，鲸目等

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模

为什么需要继承？继承的作用？

第一好处：继承的本质在于抽象。类是对对象的抽象，继承是对某一批类的抽象

第二好处：为了提高代码的复用性

extends的意思是“扩展”。子类是父类的扩展

Java中类只有单继承，没有多继承。接口可以多继承

1.继承

• 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖，组合，聚合等
• 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示

1 public class student extends Person{
2 
3 }

• 子类和父类之间，从意义上讲是is a的关系

1 student is a person
2 dog is a animal

• 类和类之间的继承是单继承

一个子类只能“直接”继承一个父类，就像是一个人只能有一个亲生父亲

一个父类可以被多个子类继承，就像一个父亲可以有多个孩子

Java中接口和接口之间，可以继承，并且是多继承

• 父类中的属性和方法可以被子类继承

子类中继承了父类中的属性和方法后，在子类中能不能直接使用这些属性和方法，是和这些属性和方法原有的修饰符（public,private,protected,default）相关的.

例如：

父类中的属性和方法使用public修饰，在子类中继承后可以直接使用

分类中的属性和方法使用private修饰，在子类中继承后不可以直接使用

父类中的构造器是不能被子类继承的，但是子类的构造器中，会隐式的调用父类中的无参构造器（默认使用super关键字）

2.Object类

java中的每一个类都是"直接"或者“间接”的继承Object类。所以每一个对象都和Object类有is a的关系。

从API文档中，可以看到任何一个类最上层的父类都是Object。

在Object类中，提供了一些方法被子类继承，那么就意味着，在java中，任何一个对象都可以继承调用这些继承过来的方法。

例如：toString方法，equals方法，getclass方法

Object类中的每一个方法以后都会使用到。

3.Super关键字

子类继承父类之后，在子类中可以使用this来表示访问或调用子类中的属性或方法，使用super就表示访问或调用父类中的属性和方法

1.super的使用

【访问父类中的属性】

 1 public class Person{
 2   protected String name ='dz';  
 3 }
 4 public class Student extends Person{
 5   private String name = "dz1";
 6   public void test(String name){
 7       System.out.println(name);
 8       System.out.println(tjhis.name);
 9     System.out.println(super.name);      
10     }   
11 }

【调用父类中的方法】

 1 public class Person{
 2   public void print(){
 3   System.out.println("Person")
 4   }  
 5 }
 6 public class Student extends Person{
 7   public void print(){
 8           System.out.println("Student")
 9     }  
10     public void test(){
11        print();
12        this.print();
13        super.print();
14     } 
15 }
16     

1212121