面向对象

一、什么是面相对象？

• 面向对象思想

  1. 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后才对某个分类下的细节进行面向过程的思索

  2. 面向对象是适合处理复杂的问题，适合处理多人协作的问题

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

• 面相对象的本质：以类的方式组织代码，以对象的形式封装数据

• 三大特性：封装，继承，多态

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

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

  public class Demo01 {
      public static void main(String[] args) {
      }
      public String sayHello(){
          return "hello,World";
      }
      public void print(){
          return;
      }
      public int max(int a,int b){
          return a > b ? a : b;
      }
      public void readFile(String file) throws IOException {//完整的方法应该有异常
      }
  }

二、回顾方法的定义

1. 修饰符、返回值类型

2. break和return的区别

   • break跳出Switch循环

   • return代表方法结束，返回一个结果

3. 方法名：注意规范（小写字母开头，驼峰规则）

4. 异常

   public class Demo02 {
       public static void main(String[] args) {
           Demo02.add(5,4);
       }
       public static int add(int a,int b){
           return a+b;
       }
   }

三、回顾方法的调用

1. 有static修饰符定义的方法是静态方法，不用实例化一个对象就能调用。

    

2. 没有static修饰符定义的方法是非静态方法，只能通过实例化一个对象来调用

   //此程序出错
   public static void a(){//通过static关键字定义的方法和类一起加载
       b();//存在的调用不存在的，所以会报错
   }
   public void b(){//类实例化之后才存在
       
   }

   public class Demo03 {
       public static void main(String[] args) {
          // Demo03.add(2,4);   出错
           Demo03 demo03 = new Demo03();
           //实际参数的类型要和形式参数的类型要相对应
           demo03.add(3,4);
       }
       public int add(int a,int b){
           return a+b;
       }
   }

四、类与对象的关系

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

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

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

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

• 张三就是人的一个具体实例，张三家里的旺财就是狗的一个实例

• 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念

五、创建与初始化对象

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);    //张信哲
?
    }
    public static void change(Person person){
//        person是一个对象：指向的 --->Person person = new Person();这是一个具体的人，可以改变属性
        person.name = "张信哲";
    }
}
?
//定义了一个Person类，有一个属性name
class Person{
    String name; //null
}

1. 使用new关键字创建对象

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

3. 类中的构造器也成为构造方法，是在进行创建对象的时候必须要调用的。

   //学生类
   public class Student {
   //    属性
       String name;
       int age;
   //方法
       public void study(){
           System.out.println(this.name+"在学习");
       }
   //学程序好，对世界进行更好的建模！---宅！音乐，旅游
   }
   ?
   ?
   ?
   ?
   public class Application {
       public static void main(String[] args) {
   //        类，抽象的，实例化
   //        类实例化后会返回一个自己的对象
   //        xh对象就是一个Student类的具体实例！
           Student xiaoming = new Student();
           Student xh = new Student();
   ?
           xiaoming.name = "小明";
           xiaoming.age = 3;
   ?
           System.out.println(xiaoming.name);
           System.out.println(xiaoming.age);
   ?
           System.out.println(xh.name);
           System.out.println(xh.age);
       }
   }

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

六、构造器详解

• 构造器

  1. 必须和类的名字相同

  2. 必须没有返回类型，也不能写void

• 作用

  1. new本质在调用构造方法

  2. 初始化对象的值

• 注意点

  1. 定义有参构造后，如果想使用无参构造，必须显示的定义一个无参构造

• alt+insert 快捷创建构造器

  public class Person {
  //    一个类即使什么都不写，它也会存在一个方法
  //    显示的定义构造器
  ?
      String name;
  //1.使用new关键字本质是在调用构造器
  //2.用来初始化值
      public Person(){
      }
  //    有参构造函数：一旦定义了有参构造函数，无参就必须显示定义
      public Person(String name){
          this.name = name;
      }
  }
  ?
  ?
  ?
  ?
  ?
  public class Application {
      public static void main(String[] args) {
  //实例化了一个对象
          Person person = new Person("张信哲");
          System.out.println(person.name);
      }
  }

七、创建对象内存分析

八、简单小结类与对象

1. 类与对象

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

2. 方法：定义和使用

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

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

   默认初始化：数字：0 0.0

   char：u0000

   boolean：false

   引用：null

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

5. 对象的创建和使用：必须使用new关键字创建对象，构造器

   Person person = new Person();
   //对象的属性person.name;
   //对象的方法person.sleep();

6. 类

   静态的属性属性

   动态的行为方法

封装、继承、多态 ---> 重点