Java面向对象思想与方法回顾

什么是面向对象

• 面向过程思想：

  • 类似线性流程，一步一步走。

• 面向对象思想：

  • 分类的思维模式，解决问题需要什么分类，然后分门别类的解决。

  • 属性+方法=类

• 面向对象编程-Object-OrientedProgramming，OOP

  • 面向对象变成的本质就是，以类的方式组织代码，以对象组织（封装）数据

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

• 认识论中先有对象后有类，对象是具体的事物，类是对对象的抽象

• 代码运行角度先有类再有对象，类是对象的模板。

回顾方法的定义及调用

方法的定义

• 写了return语句后，之后便不能写任何语句了。
• 参数列表格式：参数类型 参数名
• 异常抛出：

    }```

+ 

## 方法的调用。 
+ **同类方法直接调用，非同类非静态方法用对象调用，非同类静态方法用类名调用**

+ 不同类之间静态方法与非静态方法的调用实例：

Student类：
```package com.ilzy.blog.oop;
//student类
public class Student {
    //非静态方法
    public void say(){
        System.out.println("学生说话了");
    }
    //静态方法
    public static void say1(){
        System.out.println("学生说话了");
    }
}

Demo2类里面调用Student类里面的两个方法：

public class Demo2 {
    public static void main(String[] args) {
        //静态方法调用 带static
        Student.say1();  //可以直接调用其他类里的静态方法。
        //非静态方法，需要将类实例化。
        //对象类型 对象名 = 对象值
        Student student = new Student();
        student.say();
    }
}

• 同一个类之间静态与非静态方法调用实例：

public class Demo3 {
    public static void main(String[] args) {
        //
    }
    //静态方法同类一起加载
    public static void a(){
        b();
    }
    //非静态方法在实例化之后才存在，也就是new对象之后。
    public void b(){
        //
    }
    /*
    两个静态方法可以直接互相调用，因为静态方法在类加载之时一起加载，一同存在。
    非静态方法也可以调用静态方法，原因如上。两个非静态方法也可以被互相调用，
    因为他们的类在实例化后一起被创建。而已经加载的静态方法便无法调用未被实例化的
    非静态方法，只因其时间片不同。
     */
}

• 同一个类中实例化调用方法的两种写法：

import com.sun.org.apache.bcel.internal.generic.NEW;
public class Demo4 {
    public static void main(String[] args) {
        //用实例化调用方法的两种写法。
        //1.先new当前类，然后调用并赋值
        Demo4 demo4 = new Demo4();
        demo4.add(3,4);
        System.out.println(demo4.add(3,4));
        // 2.直接new当前类，调用并赋值
        new Demo4().add(2,4);
        System.out.println(demo4.add(2,4));
    }
    public int add(int a,int b){
        return a+b;
    }
}

• 值传递实例：

public class Demo5 {
    //值传递
    public static void main(String[] args) {
        int a =1;
        System.out.println(a);
        Demo5.change(a);
        System.out.println(a);  //一定是1
    }
    //无返回值，也即是主方法里将a=1传递进来给a这个形参，
    // 然后运行了一下a=10这个语句，并不影响实参a=1。
    public static void change(int a){
        a =10;
    }
}

• 引用传递实例：

//引用传递,传递了一个对象，但本质上仍是值传递
public class Demo6 {
    public static void main(String[] args) {
        Person person = new Person();  //将Person类实例化，new一个Person类型的名叫person的类。
        System.out.println(person.name);  //null
        change(person);  //调用Demon5类下的静态方法change，参数为person类。
        System.out.println(person.name);  //renmin
    }
    public static void change(Person person){  
        person.name="renmin";
        //person当前是一个对象，指向的是Person这个类。
        /*
        向Demon5类下的change方法传递Person类型的名为person的对象
        的形参，并书写方法体，内容为将被new为person对象的Person类
        的name属性赋值为“renmin”
         */
    }
}
//一个类里只能有一个public class，但是可以有多个class
//定义一个Person类，有一个属性：name。
class Person{
    String name;  //默认值为null
}