Day8_面向对象

面向对象

面向对象&面向过程

一、面向过程思想

1. 步骤清晰简单，第一步做怎么，第二步做怎么

2. 适合处理一些简单的问题

二、面向对象思想

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

2. 适合处理复杂的问题，适合需要多人协作的问题

三、什么是面向对象

1. 面向对象编程：Object-Oriented Programming，OOP

2. 面向对象编程本质：以类的方式组织代码，以对象的方式组织(封装)代码

3. 抽象

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

四、方法的回顾和加深

1. 方法的定义

   1. 修饰符：定义该方法的访问类型

   2. 返回值类型：指定方法返回的数据类型。可以是任意有效类型；如果方法没有返回值类型必须是void，void不能省略；返回值类型和方法体中的返回值要一致

   3. 方法名：通常以英文中的动词开头

   4. 参数列表：由类型和标识符组成，每个参数用逗号隔开，方法可以没有参数，但是括号不能省略

   package com.oop;
   ​
   public class Demo1 {
       public static void main(String[] args) {
   ​
       }
   //方法
       /*
       修饰符 返回值类型 方法名 (参数列表){
           //方法体
           return 返回值;
       }
       */
       public String sayHello(){
           return "Hello,World";
       }
       public void print(){
           return;
       }
   }

2. 方法的调用

   1. 静态方法：static

      package com.oop;
      ​
      public class  Demo02 {
          public static void main(String[] args) {
              Student.say();
          }
      }
      //**********************************
      package com.oop;
      public class Student {
          public static void say(){
              System.out.println("说话");
          }
      }

       

   2. 非静态方法

      package com.oop;
      ​
      public class  Demo02 {
          public static void main(String[] args) {
              Student student = new Student();
              Student.say();
          }
      }
      //**********************************
      package com.oop;
      public class Student {
          public void say(){
              System.out.println("说话");
          }
      }

       

   3. 同一个类下的非静态方法可以直接调用

      package com.oop;
      ​
      public class  Demo02 {
          public static void main(String[] args) {
              public void a(){
                  b();
              }
              public void b(){
                  
              }
          }
      }

       

   4. 形参和实参

   5. package com.oop;
      ​
      public class Demo03 {
          public static void main(String[] args) {
              //实际参数类型和形式参数类型要对应
              int add = Demo03.add(1,2);
              System.out.println(add);
          }
          public static int add(int a,int b){
              return a+b;
          }
      }

   6. 值传递：实际参数把他的值传递给对应的形式参数，方法执行中形式参数值得改变不影响实际参数的值。

          package com.oop;
      //值传递
      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 =10;
          }
      }

       

   7. 引用传递：也称传地址。实际参数的引用被传递给方法中对应的形式参数，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，方法执行中形式参数值得改变将会影响实际参数值。（传递地址值的数据类型为除了String以外的所有符合数据类型，包括数组，类和接口）

      package com.oop;
      //值传递
      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 = "wei";
          }
      }
      ​
      //定义一个Person类，有一个属性
      class Person{
          String name;
      }

       

    

五、类与对象的关系

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

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

六、创建和初始化对象

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

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

   2. 类中的构造器也称构造方法，是进行创建对象的时候必须调用的，构造器有以下特点：

      1. 必须和类的名字相同

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

   3. //类名 对象名 = new 类名()
      Person person = new Person;

2. 构造方法

   1. 名称必须和构造方法相同，

   2. 不返回任何数据，也不需要void声明

   3. 作用是创建对象并初始化成员变量

   4. 一般用public声明

   5. 每个类至少有一个构造方法，如果不定义构造方法，java将提供一个默认的不带参数且方法体为空的构造方法

   6. 构造方法可以重载

   7. package com.oop.demo02;
      ​
      //学生类
      public class Student {
          //即使一个类怎么都不写，他也存在一个方法
          //属性
          String name;
          int age;
      ​
          //使用new关键字，本质是调用构造器
          //用来初始化值
          public Student(){
      ​
          }
          //有参构造：一旦定义了有参构造，无参就必须显示定义
          public Student(String name){
              this.name = name;
          }
          
          //方法
          public void study(){
              System.out.println("我爱学习");
          }
      }
      ​
      package com.oop.demo02;
      ​
      //一个项目类应该只存在一个main方法
      public class Application {
          public static void main(String[] args) {
              Student xm = new Student();
              System.out.println(xm.name);
              xm.study();
              System.out.println();
      ​
          }
      }

   8. //alt+insert(锁数字键)，生成构造器

3. 创建对象内存分析

    

4. 小结

   /*1.类和对象
   类是一个模板：抽象，对象是一个具体的实例
   2.方法：
   定义，调用
   3.对应的引用：
   引用类型，基本类型（8）
   对象是通过引用来操作的：栈--->堆
   4.属性：字段field 成员变量
   默认初始化：
   数字：0 0.0
   char：u0000
   boolean：false
   引用：null
    修饰符 属性类型 属性名 = 属性值！
   5.对象的创建和使用：
   必须使用new关键字创造对象，构造器，Person person =new Person()
   对象的属性 person.name
   对象的方法 person.sleep()
   6.类：
   静态属性 属性
   动态行为 方法
    */