(二)面向对象

面向对象

基本概念

面向对象&面向过程

• 以类的方式组织代码 以对象的方式组织数据

• 抽象：把 像的地方 抽取出来

  • 封装：只留下一个小口

  • 继承：继承到了父亲所有的钱，还能自己挣

  • 多态：都是学习(这个方法)，但是你和小明学得结果不太一样

回顾方法

方法定义

 package com.oop.demo01;
 ​
 import java.io.IOException;
 ​
 //Demo01类
 public class Demo01 {
 ​
     //main方法 用于启动项目，一个项目只有一个main方法，之前的每个类都有一个main方法是为了启动方便
     public static void main(String[] args) {
 ​
     }
 ​
     /*
     修饰符 返回值类型 方法名（方法的参数）{
         //方法体
         return 返回值；
     }
      */
     public String sayHello(){
         return "hello,world";
     }
     public void sauHello(){
         return; //可以默认不写
     }
     public int max(int a,int b){
 ​
         return a > b ? a : b; //三元运算符
     }
 ​
     /*
     return 和 break 的区别
     return:return之后方法就结束了；返回值与返回值类型一致；
     break：可以跳出switch，结束循环，(continue结束当前循环)
      */
 ​
     /*
     方法名：驼峰命名法，见名知意
      */
 ​
     /*
     参数类型，参数名；
     一个方法可以有多个参数；
     可变长参数
      */
 ​
     public void readFile(String file) throws IOException{
         //读文件，抛IO流的异常
         //数组下标越界的异常
     }
 }
 ​
 ​

 

方法调用

对于非静态的方法，使用new关键字 ：

 // 对象类型 对象名 = 对象值；   (输入 new Student();，按下alt+Enter)
 Student student = new Student();
 student.say();

对于静态方法，直接用类名调用：

 Studen.say();

 

 

值传递

 package com.oop.demo01;
 ​
 //值传递
 public class Demo04 {
     public static void main(String[] args) {
         int a = 1;
         System.out.println(a);
 ​
         Demo04.change(a);
         System.out.println(a);
     }
     public static void change(int a){
         a = 11;
     }
 }
 ​
 ​
 结果：
     1
     1

引用传递

 错误示例：
 package com.oop.demo01;
 ​
 //引用传递：传递对象，本质还是值传递
 public class Demo05 {
     public static void main(String[] args) {
         Person person = new Person();
         System.out.println(person.name);
     }
     //定义了一个Person类
 //   有一个属性叫做 name
     class Person{
         String name;
     }
 }
 错误提示：Error:(7, 25) java: 无法从静态上下文中引用非静态 变量 this

 正确操作
 package com.oop.demo01;
 ​
 //引用传递：传递对象，本质还是值传递
 public class Demo05 {
     public static void main(String[] args) {
         Person person = new Person();
         System.out.println(person.name);
     }
 ​
 }
 ​
 //定义了一个Person类
 //   有一个属性叫做 name
 class Person{
     String name;
 }
 返回值：null      (默认填充null)

一样，我们执行 change方法，记得换参数：

 package com.oop.demo01;
 ​
 //引用传递：传递对象，本质还是值传递
 public class Demo05 {
     public static void main(String[] args) {
         Person person = new Person();
         System.out.println(person.name);
         Demo05.change(person);
         System.out.println(person.name);
     }
     public static void change(Person person) {
         person.name = "xiaofanqie";
     }
 ​
 }
 ​
 //定义了一个Person类
 //   有一个属性叫做 name
 class Person{
     String name;
 }
 ​
 运行结果：
     null
 xiaofanqie

 

类与对象的关系

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

• 对象是抽象概念的具体类型

 

创建与初始化对象

• 使用new关键字创建对象

• 使用new来创建对象，会给我们的对象分配一个内存空间。除此之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。

举例：

 

• 类中的构造器也称为构造方法，实在创建对象的时候必须要调用的。

• 构造器特点：

  • 必须和类名相同

  • 必须无返回值，且无void关键字

 

IDEA查看class文件的方法(第一步是 Project Structure)：

 

查看Person类的.class的文件：

发现：

• 一个类即使什么都不写也会存在一个方法，现在的public Person() 方法就是 构造方法。无参构造。

 

注意：

• 使用new关键字，必须要有构造器。因为它本身是在调用构造器

• 一旦定义了有参构造，无参构造就必须显示定义，否则无效

• 构造器的作用：实例化——初始化对象的值

 

例子：

定义了无参构造器，返回null(构造器给了一个初始值：null)

构造函数中用 this 赋值，输出赋给的值

可以打断点debug一下：

从断点处跳转到左侧执行，执行完构造函数后，name有值，变成 fan；此时生成了对象。

跳转回主函数继续执行，就有了person.name = fan

 

定义有参构造

 

 

用例分析内存空间：

 

回顾与小结

• 类与对象

  • 类是模板，抽象；

  • 对象是实例，具体；

• 方法

  • 定义 调用

• 对象的引用

  • 引用类型 VS 基本类型(8大)

  • 对象是通过引用来操作的：栈来操作堆；

• 属性(字段Field，成员变量)

  • 默认初始化：

    • 数值： 0 0.0

    • char： u0000

    • Boolean：false

    • 引用：null

  • 修饰符 属性类型 属性名 = 属性值

• 对象的创建和使用

  • 必须使用new关键字创造对象，构造器 Person fan = new Person();

  • 对象的属性 fan.name

  • 对象的方法 fan.speak();

• 类：

  • 静态的属性 属性

  • 动态的行为 方法

• java面向对象的三大特征

  • 封装、继承、多态

 

封装

 

• 封装的意义：

  • 提高程序的安全性，保护数据

  • 隐藏代码的实现细节

  • 统一接口(所有的接口都是get、set)

  • 系统的可维护性增加了

继承

 

• 子类继承父类的全部public的方法

  • 

• 对父类private的属性可以通过get、set获得

  • 

• 将鼠标放在类中按下 ctrl+H 可以看到类的结构树

  • 

  • java中，所有类都默认直接或间接继承了 object 类

  • java中，只有单继承没有多继承(一个儿子只有一个爸爸 一个爸爸可以有多个儿子)

super关键字

• 

•  

  第一个name 测试类application传给他的参数

  第二个name student类中使用表示这个类的name

  第三个name 父类中的protected标识属性可以通过super 获取到

• 

可以看到 print() 和 this.print() 都是调用了Student类中的print方法

super.print()则调用了父类的print()方法

• 

当将父类的print() 改为 private修饰时，子类通过 super 关键字 也不能访问

• 

测试类只留下 new 的构造函数，发现先执行了父类的构造器，接下来执行子类的构造器。

说明在子类的构造器中有隐藏的代码 super()；

• 将 super 显示定义在 Student 类中

  • 

• 当将 super(); 语句放到第二条时会报错--> 调用父类的构造器必须在子类的第一行

  •