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

本文链接：https://blog.youkuaiyun.com/weixin_44083249/article/details/90055336

本文深入讲解面向对象编程的核心概念，包括类与对象、抽象数据类型、构造方法、this关键字、继承、重写与重载等关键知识点，通过实例演示如何在Java中实现面向对象的设计。

面向对象程序设计

一、面向对象的思想
- A：面向过程：
  强调的是过程，所有事情都需要自己完成
- B：面向对象：
  是一种更符合我们思想习惯的思想（懒人思想，我把事情自己不做，交给别人做）
  可以将复杂的事情简单化（对使用者来说简单了，对象里面还是很复杂的）
  将我们从执行者变成了指挥者角色发生了变化
- 定义：
  首先根据客户的需求抽象出业务逻辑对象；
  然后根据需求进行合理的分层；
  构建对应的独立的业务模块；
  之后进行设计业务逻辑，利用封装、继承、多态、抽象的思想实现实际业务需求；
  最后通过整合各个模块，达到高内聚、低耦合的效果，从而满足客户的需求。

例句：打印学生的成绩信息
package com.until.day05;
 //学生的实体类对象
public class Student {
  String name = "p";//姓名
  int age = 20;//年龄
 char gender = '男';//性别
 double score = 40;//分数
public void printStuInfo(){
  System.out.println("姓名：" + name);
  System.out.println("年龄：" + age);
  System.out.println("性别：" + gender);
  System.out.println("分数：" + score);
 }
}

package com.until.day05;
public class Until51 {
 public static void main(String[] args){
  //创建学生对象		
  Student student1 = new Student();		
  student1.name = "小泽";
  student1.age = 20;
  student1.gender = '男';
  student1.score = 99;	
  student1.printStuInfo();		
  }
}

二、什么是抽象数据类型？
- 所谓的抽象数据类型可以理解为：将不同类型的数据的集合组成一个整体用来描述一种新的事物。
三、什么是类？
- （1）类定义了一种抽象数据类型；
- （2）类不但定义了抽象数据类型的组成（成员变量），同时还定义了可以对该类型实施的操作（方法）。
四、类与对象（一）
- (1)定义类的成员变量
- (2)类的定义包括“成员变量”的定义和“方法”的定义，其中"成员变量"用于描述该类型对象共同的数据结构。
- (3)Java语言中，类的成员变量的定义可以使用如下语法：
  - ```
  class类名{
     成员变量类型 变量名称；
     ......
  }
```
- (3)成员变量的类型默认初始值
  数值类型（byte、short、int、long、float、double） 0
  Boolean型 false
  Char型 false/u0000
  引用类型 null
类与对象（二）
- (1)类中除了定义成员变量，还可以定义方法，用于描述对象的行为，封装对象的功能。
- (2)Java语言中，类的成员变量的定义可以使用如下语法：
  - ```
  class类名{
     修饰词 返回值类型 方法名称[参数列表]{
     方法体 ......
  }
  ......
  }
```
五：成员变量和局部变量
- 局部变量和成员变量的区别
  - 1、定义位置：成员变量定义在类中；
    局部变量定义在方法中。
    2、作用域：成员变量作用在整个类中；
    局部变量值只能作用在定义它的方法中或者是语句中使用。
    3、内存中：成员变量存储在堆内存中；并且在堆内存中自动赋予初始值；
    局部变量存储在栈内存中，不会自动赋值。
    4、生命周期：成员变量在对象创建的时候存储在堆内存中，在对象被收回的时候销毁；
    局部变量在方法或者是语句中执行的时候被创建，方法或者是语句执行完之后被销毁。
- ```
 例句：
package com.until.day05;
public class Until53 {
 public static void main(String[] args){
	int x = 5;//全局变量
	{
		x = 6;
    	int y = 7;//局部变量
	   System.out.println(x);
		System.out.println(y);
	}
 	System.out.println(x);
 }
}
```
六、方法的重载（overload）（方法名相同，而参数列表不同）
- （1）方法的签名包含如下两个方面：方法名和参数列表
  （2）一个类中，不可以有两个方法的签名完全相同，即一个类中不可以有两个方法的方法名和参数列表都完全一样。
  （3）如果一个类的两个方法只是方法名相同而参数列表不同，是可以的。
- ```
例句：
package com.until.day05;
public class Until54 {
public static void main(String[] args){
int num = 10;
double money = 100;
say(num);
say(money);		
}
public static void say(int num){
   System.out.println("数字：" + num);
}
public static void say(double money){
System.out.println("钱为：" + money);
}
}
```
七、构造方法
- （一）构造方法的语法格式：
  - 构造方法是在类中定义的方法，不同于其他的方法，构造方法的定义有如下两点规则：
    (1)构造方法的名称必须与类名相同；
    (2)构造方法没有返回值，但也不能写void。
  - ```
  语法：
  [访问修饰符] 类名(){
    //构造方法体;
  }
```

 例句：
package com.until.day05;
/*构建构造方法*/
public class StudentA {
   String name;
   int age;
   String address;
  //构造方法
  public StudentA(){
    System.out.println("这就是一个构造方法！");
  }
 //构造方法的重载
public StudentA(String name){
  this.name = name;
}
public StudentA(String name,int age,String address){
  this.name = name;
  this.age = age;
  this.address = address;
  }
//成员方法
public void printInfo(){
  System.out.println("姓名：" + name + "年龄：" + age + "地址：" + address);
 }
}
package com.until.day05;
//测试构造方法
public class TestA {
  public static void main(String[] args){
     StudentA s = new StudentA();
 	 s.name = "苍老师";
     s.age = 80;
     s.address = "北京";
     s.printInfo();
     System.out.println("=========");
     StudentA s1 = new StudentA("老王");
     System.out.println(s1.name);
  	System.out.println("========");
	StudentA s2 = new StudentA("pp",7,"北京");
	System.out.println("姓名"+ s2.name + "年龄" + s2.age + "地址：" + s2.address);
  }
}

（二）构造方法的应用
- 构造方法常用语实现对象成员变量的初始化。
八、this关键字
- （1）this关键字在方法体中，用于指向调用该方法的当前对象;
  简单来说：哪个对象调用方法，this指的就是哪个对象。
  严格来讲在方法中需要铜鼓this关键字指明当前对象对象。
  - 例如：
    public void drop(){
    this.row ++;
    }
- （2）为了方便起见，在没有歧义的情况下可以省略this。
  - 例如：
    public void drop(){
    row ++;
    }
九、类和方法的使用
- （一）继承
  - 发现一些类中的属性和方法是相同的，所以把这些相同的属性和方法提取到一个新的类中，
    然后利用extends关键字，让原来的类和新的类产生联系，这种联系称之为继承。
- （二）extends关键字
  - （1）通过extends关键字可以实现类的继承；
  - （2）子类（Sub class）可以继承父类（Super class）的成员变量及成员方法，
    同时也可以定义自己的成员变量和成员方法
  - （3）Java语言不支持多重继承，一个类只能继承一个父类，但一个父类可以有多个子类。
- （三）重写和重载
  - 重写和重载是完全不同的语法现象，区别如下：
    - （1）a: 重载是指在一个类中定义多个方法名相同但参数列表不同的方法，在编译时，根据参数的个数和类型来决定绑定哪个方法。
    - b:重写是指在子类中定义和父类完全相同的方法，在程序运行时，根据对象的类型不同（而不是引用类型）二调用不同的版本。
    - （2）a:重载遵循所谓“编译期绑定”，即在编译时根据参数变量的类型判断应该调用哪个方法; 因为：变量obj的类型为super，因此：Goo的g(super)方法被调用。
      b:重写遵循所谓"运行期绑定"，即在运行的时候根据引用变量指向的实际对象类型调用方法;
      因为：objz实际指向的是子类的对象，因此:子类重写后的f方法被调用。

例句：
package com.until.day05;
 public class Super {
  public void f(){
  System.out.println("super.f()");
  }
  public static void main(String[] args) {
  Super obj = new Sub();
  Goo goo = new Goo();
  goo.g(obj);
  }
}
  class Sub extends Super{
  public void f(){
  	System.out.println("sub.f()");
  }
  }
  class Goo{
  public void g(Super obj){
  	System.out.println("g(Super)");
  }	
  public void g(Sub obj){
      System.out.println("g(Sub)");
  }
  }