Java基础之（十三）：类与对象

初识面向对象

面向对象 & 面向过程

• 面向过程思想
  • 步骤清晰简单，第一步做什么，第二步做什么.....
  • 面向过程适合处理一些较为简单的问题
• 面向对象思想
  • ​ 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
  • 面向对象适合处理复杂的问题，适合处理需要多人协作的问题！
• 对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

什么是面向对象

• 面向对象编程（Object-Oriented Programming, OOP）
• 面向对象编程的本质就是：**以类的方式组织代码，以对象的形式组织（封装）数据。
• 抽象
• 三大特性：
  • 封装：把数据进行包装起来，留一个接口（将属性私有化并提供公共的访问接口）
  • 继承：A类继承B类，A类就有了B类的所有特征
  • 多态：同一事物在不同属性下有着不同的表现结果
• 从认识论的角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象
• 从代码运行角度考虑是先有类后有对象。类是对象的模板。

方法回顾和加深

• 方法的定义

  • 修饰符
  • 返回类型

  格式：

  修饰符 返回值类型 方法名(...){
  
  //方法体
  
  return 返回值；
  
  }

  //main 方法
  public static void main(String[] args) {
  }
  /*
  修饰符 返回值类型  方法名(...){
      //方法体
      return 返回值；
  }
   */
  //return 结束方法，返回一个结果！
  public String sayHello(){
      return "hello,world";
  }
  public void hello(){
      return;
  }
  public int max(int a,int b){
      return a>b?a:b;//三元运算符！
  }
  

  • break：跳出switch，结束循环 和 return 的区别
  • 方法名：注意规范 见名知意
  • 参数列表：（参数类型，参数名）...
  • 异常抛出

  //数组下标越界异常： Arrayindexoutofbounds
  public void readFile(String file) throws IOException {
  }
  

• 方法的调用：递归

  • 静态方法

  先定义一个Student类

  public class Student {}
  

  //静态方法
  public static void say(){
      System.out.println("学生");
  }
  

  • 非静态方法

  //非静态方法
  public void sing(){
      System.out.println("教师");
  }
  

  然后使用别的类来调用

  public class Demo02 {
      public static void main(String[] args) {
          //静态方法  static
          Student.say();
          //非静态方法
          //第一种方法：实例化这个类 new
          new Student().sing();
          //第二种方法：
          //对象类型  对象名  =   对象值;
          Student student = new Student();
          student.sing();
      }
      //静态方法只能调用静态方法，非静态方法可以调用静态方法
      //和类一起加载的
      public static void a(){
         // b();
      }
      //类实例化之后才存在
      public void b(){
      }
  }
  

  • 形参和实参

  public static void main(String[] args) {
      //实际参数和形式参数的类型要对应
      int sum1 = Demo03.add1(1,2);
      System.out.println(sum1);
      Demo03 demo03 = new Demo03();
      int sum2 = Demo03.add2(2,3);
      System.out.println(sum2);
  }
  public static int add1(int a,int b){
      return a+b;
  }
  public static int add2(int a,int b){
      return a+b;
  }
  

  • 值传递和引用传递

  值传递：

  //值传递
  public class Demo04 {
      public static void main(String[] args) {
          int a = 1;
          System.out.println(a);
          Demo04.change(a);
          System.out.println(a);//1
      }
      //返回值为空
      public static void change(int a){
          a=10;
      }
  }
  

  引用传递

  //引用传递: 对象，本质还是值传递
  public class Demo05 {
      public static void main(String[] args) {
          Person person = new Person();
          System.out.println(person.name);//null
          Demo05.change(person);
          System.out.println(person.name);//lei
      }
      public static void change(Person person){
  		//person是一个对象：指向的 ---> Person person = new Person();这是一个具体的人，可以改变属性！
          person.name = "lei";
      }
  }
  //定义了一个Person类，有一个属性：name
  class Person{
      String name;//null
  }
  

  • this关键字: 表示当前的类或者对象

对象的创建分析

类与对象的关系

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

  • 动物、植物、手机、电脑......

  • Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体的事物应该具备的

    特点和行为

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

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

创建与初始化对象

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

public static void main(String[] args) {
    //类：抽象的。实例化
    //类实例化后会返回一个自己的对象！
    //student对象就是一个student类的具体实例！
    Student xiaoming =new Student();
    Student xh =new Student();
    xiaoming.name = "小明";
    xiaoming.age = 3;
    System.out.println(xiaoming.name);
    System.out.println(xiaoming.age);
    xh.name = "小红";
    xh.age = 3;
    System.out.println(xh.name);
    System.out.println(xh.age);
}

//学生类
public class Student {
    //属性：字段
    String name;
    int age;
    //方法
    public void study(){
        System.out.println(this.name+"在学习");
    }

• 类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点：
  • 1. 必须和类的名字相同
  • 1. 必须没有返回类型，也不能写void

//一个类即使什么都不写，它也会存在一个方法
//显示的定义构造器
String name;
int age;
//实例化初始值
//1. 使用new关键字，本质是在调用构造器
//2. 用来初始化值
public Person() {
}
//有参构造: 一旦定义了有参构造，无参构造必须显示定义
public Person(String name) {
    this.name = name;
}
//alt + insert
public Person(String name, int age) {
    this.name = name;
    this.age = age;
}
/*
    构造器：
    	1. 和类名相同
    	2. 没有返回值
    作用：
        1. new  本质在调用构造方法
        2. 初始化对象的值
    注意点：
        1. 定义有参构造之后，如果想要使用无参构造，显示的定义一个无参的构造。
        Alt + Insert
        this. =
*/

public static void main(String[] args) {
        //new 实例化了一个对象
        Person person = new Person("xuesheng",3);
        System.out.println(person.name);//xuesheng
    }

创建对象内存分析

import com.oop.demo03.Pet;
public class Application {
    public static void main(String[] args) {
        Pet dog = new Pet();
        dog.name = "旺财";
        dog.age = 3;
        dog.shout();
        System.out.println(dog.name);
        System.out.println(dog.age);
    }
}

public class Pet {
    public String name;
    public int age;
    //无参构造
    public void shout(){
        System.out.println("叫了一声");
    }
}

简单小结类与对象

1. 类与对象

   ​ 类是一个模板，对象是一个具体的实例

2. 方法

   ​ 定义、调用！

3. 对象的引用

   ​ 引用类型： 基本类型（8）

   对象是通过引用来操作的：栈--->堆

4. 属性：字段Field 成员变量

   • 默认初始化：
     • 数字： 0 0.0
     • char : u0000
     • boolean: false
     • 引用：null
   • 修饰符 属性类型 属性名 = 属性值！

5. 对象的创建和使用

   • 必须使用new关键字创造对象，构造器 Person student = new Person();
   • 对象的属性 student.name
   • 对象的方法 student.sleep()

6. 类：

   ​ 静态的属性 属性

   ​ 动态的方法 方法