面向对象编程

面向对象编程

初识面向对象

• 面向过程&面向对象
  • 面向过程思想（具体；微观）
    • 步骤清晰简单，第一步做什么，第二步做什么
    • 适合处理一些较为简单的问题
  • 面向对象思想（抽象；宏观；OOP）
    • 物以类聚，分类的思维模式，思考问题首先会解决问题需要的哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
    • 面向对象适合处理复杂的问题，适合处理需要多人协作的问题
• 面向对象的本质
  • 以类的方式组织代码，以对象的组织（封装）数据
• 面向对象三大特性
  • 封装
  • 继承
  • 多态
• 先有对象后有了类。对象是具体的事物，类是抽象的，是对对象的抽象。类是对象的模板。

方法的调用

• 通过类名、方法名的调用

  //类1（定义方法）
  package com.zt.oop.demo01;
  
  public class Student {
      //静态方法
      public static  void add(){
          System.out.println("Hello");
      }
  
      //非静态方法
      public void say(){
          System.out.println("Hello");
      }
  }
  
  //类2（调用）
  package com.zt.oop.demo01;
  
  public class Demo02 {
      public static void main(String[] args) {
          //静态方法
          Student.add();
  
          //非静态方法
          Student student = new Student();
          student.say();
      }
  }
  

  //实际参数和形式参数在有无static下调用
  package com.zt.oop.demo01;
  
  public class Demo03 {
      public static void main(String[] args) {
          //实际参数和形式参数的类型要对应
          int add = Demo03.add(1, 2);
          System.out.println(add);
  
          int i = new Demo03().add2(2, 2);
          System.out.println(i);
      }
  
      public static int add(int a , int b){
          return a + b;
      }
  
      public  int add2(int a , int b) {
          return a+b;
      }
  }
  
  

  //值传递(可以通过断点了解原因)
  package com.zt.oop.demo01;
  
  public class Demo04 {
      public static void main(String[] args) {
          int a = 1;
          System.out.println(a); //1
  
          Demo04.chang(a);
          System.out.println(a); //1
      }
  
      public static void chang(int a){
          a = 10;
      }
  }
  
  

  //引用传递：对象， 本质还是值传递
  package com.zt.oop.demo01;
  public class Demo05 {
      public static void main(String[] args) {
          Perosn perosn = new Perosn();
          System.out.println(perosn.name); //null
  
          Demo05.chang(perosn);
          System.out.println(perosn.name); //海王
      }
  
      public static void chang(Perosn perosn){
          perosn.name="海王";
      }
  }
  
  //定义一个perosn类，有一个属性：name
      class Perosn{
          String name;
      }
  
  

类与对象的关系

• 类是一种抽象的数据类型，它是对某一事物整体描述/定义，但是并不能代表某一个具体的事物。
• 对象是抽象概念的具体实例
  • 张三就是人的具体实例，旺财就是狗的具体实例
  • 体现特点，展现功能的具体实例，而不是一个抽象的概念

创建与初始化对象

• 使用new关键字创建对象

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

• 构造器也称构造方法，是在创建对象的时候必须要调用的。并有两个特点：

  • 必须和类的名字相同。
  • 必须没有返回值类型，也不能写void。

  package com.zt.oop.demo02;
  
  //学生类
  public class Student {
  
      //属性:字段
      String name;    //null
      int age;        //0
  
      //方法
      public void study(){
          System.out.println(this.name+"在学习");    //this指代当前类Student
      }
      
      /*
      //初始化类
      public static void main(String[] args) {
  
          //类：抽象的，实例化
          //类实例化后会返回一个自己的对象；
          //student对象就是一个Stdent类的具体实例
          Student xiaoming = new Student();
          Student xh = new Student();
  
          xiaoming.name="海王";
          xiaoming.age=23;
  
          System.out.println(xiaoming.name);
          System.out.println(xiaoming.age);
  
          System.out.println(xh.name);    //null
          System.out.println(xh.age);     //0
      }
  
       */
  }
  

构造器

• 案例

  public class Person {
      //一个类即使什么都不写，它也会存在一个方法
      //显示的定义构造器
  
      String name;
  
      //无参构造：默认的构造器
      //1.使用new关键字，本质是在调用构造器
      //2.用来初始化值
      public Person(){
      this.name = "海王";   //this指代对象的name
      }
  
      //方法重载
      //有参构造：一旦定义了有参构造，无参就必须显示定义
      public Person(String name){
          this.name = name;   //this指代括号的name
      }
  }
  
  /*
   public static void main(String[] args) {
  
          Person person = new Person("hello");
          System.out.println(person.name);
      }
  
      构造器：
          1.和类名相同
          2.没有返回值
      作用：
          1.new本质在调用构造方法
          2.初始化对象的值
      注意点：
          1.定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造
  
          Alt + insert 生成构造器
   */
  

创建对象内存分析

• 案例

  public class Application {
      public static void main(String[] args) {
          Pet dog = new Pet();
          dog.name="海王";
          dog.age=23;
          dog.shout();
  
          System.out.println(dog.name);
          System.out.println(dog.age);
  
          Pet cat = new Pet();
  
      }
  }
  
  /*
  public class Pet {
     public String name;
     public int age;
  
      //无参构造
  
      public void shout(){
          System.out.println("叫了一声");
      }
   */
  

  

小结

 /*
    1.类与对象
        类是一个模板：抽象，对象是一个具体的实例

    2.方法
        定义、调用

    3.对应的引用
        引用类型 ： 基本类型（8个）
        对象是通过引用来操作的：栈---->堆

    4.属性：字段  成员变量
        默认初始化：
            数字：0    0.0
            char：u0000
            boolean:false
            引用类型：null

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

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

    6.类
        静态的属性： 属性
        动态的行为： 行为
       面向对象三大特征： 封装、继承、多态

     */

标签：name,void,System,面向对象编程,println,public,out
来源： https://www.cnblogs.com/zhinice/p/16385242.html