1、面向过程编程与面向对象编程

  • 面向过程POP-Procedure Oriented Programming：考虑的是整个事件完成需要经过几个步骤，重点关系的是过程。

  • 面向对象OOP-Object Oriented Programming：考虑的是整个事件完成有哪些对象（事物）参与进来

    2、面向对象基本概念

  • 类：一组具有相同特征（属性/成员变量）和行为（成员方法/方法）的事物的集合。

  • 对象：万事万物皆对象，具体的个体。

  • 类和对象的关系：抽象与具体的关系；类是一个抽象的概念，对象是一个具体的个体

    3、类的组成与定义

  • 类的组成：属性 + 方法（扩展：还可以有成员内部类、代码块）

    • 属性：刻画这一类事物的特征
    • 方法：刻画这一类事物的行为

  • 类的定义语法

    1.       [修饰符] class 类名{
    2.           [修饰符] 类型 属性名;
    3.           返回值类型 方法名(形参列表){
    4.           }
    5.       }

  • 类的实例化

    • 类名 对象名 = new 类名();
  • 访问类的属性：对象名.属性名;

  • 访问类的方法：对象名.方法名(形参列表); ``` Person.java public class Person {

    public String name;

    public int age;

    public void move(){

    1.   System.out.println(name+"开始走路");

    } }

Main.java public class Main {

  1. public static void main(String[] args) {
  3.     Person person = new Person();
  4.     // null 成员变量的默认值
  5.     System.out.println(person.name);
  6.     // 0    成员变量的默认值
  7.     System.out.println(person.age);
  9.     person.age = 12;
  10.     person.name = "tom";
  11.     System.out.println(person.name);
  12.     System.out.println(person.age);
  14.     // 调用方法
  15.     person.move();
  16. }

}

  1. <a name="J60Dq"></a>
  2. ### 4、构造方法
  4. - 构造方法：实例化对象new时调用的方法
  5. - 特征：方法名与类名相同；无返回值类型的声明
  6. - 类里有一个默认的无参构造方法（隐式构造方法），如果写了带参数的构造方法，实例化对象时又想用无参构造方法，则必须把无参构造方法写出来

public class Person {

  1. public String name;
  3. public int age;
  5. public Person(String name, int age) {
  6.     this.name = name;
  7.     this.age = age;
  8. }
  10. public Person(String name) {
  11.     this.name = name;
  12. }
  14. public Person(int age) {
  15.     this.age = age;
  16. }
  18. public Person() {
  20. }

}

  2. - 构造方法的调用
  1.     Person p1 = new Person();
  2.     Person p2 = new Person(12);
  3.     Person p3 = new Person("tom");
  4.     Person p4 = new Person("tom", 12);
  1. <a name="iGLXG"></a>
  2. ### 5、成员变量和局部变量
  4. - 成员变量（在类中定义，用来描述对象的属性）
  5.    - 作用域：在整个类内部都是可见的
  6.    - java会给成员变量一个初始值
  7.    - 成员变量和局部变量同名时，局部变量具有更高的优先级
  8. - 局部变量（在类的方法中定义，在方法中临时保存数据）
  9.    - 作用域：仅限于定义它的方法
  10.    - java不会给局部变量赋予初始值
  11.    - 同一个方法中，不允许有同名局部变量；不同的方法可以有同名的局部变量

public class Person {

  1. public String name;
  3. public int age;
  5. public Person(String name, int age) {
  6.     this.name = name;
  7.     this.age = age;
  8. }
  10. public Person(String name) {
  11.     this.name = name;
  12. }
  14. public Person(int age) {
  15.     this.age = age;
  16. }
  18. public Person() {
  20. }
  22. public void move(){
  23.     String name = "Jack";
  24.     // 此处使用的name是局部变量 Jack
  25.     System.out.println(name+"开始走路");
  26.     // this使用的name是成员变量
  27.     System.out.println(this.name+"开始走路");
  28. }

}

  1. <a name="fxhFX"></a>
  2. #### this关键字
  4. - this关键字的作用
  5.    - this用在构造方法里，区分成员变量和局部变量重名的情况，表示当前对象
  6.    - this用在构造方法里，在一个构造方法里调用另一个构造方法，this语句一定要处于整个构造方法的第一行
  7.    - this用在普通方法里，在访问成员变量和其它方法时，在前面会默认加上this

public class Person {

  1. public String name;
  3. public int age;
  5. public Person(String name, int age) {
  6.     this.name = name;
  7.     this.age = age;
  8. }
  10. public Person() {
  11.     this("tom",12);
  13. }

}

  1. <a name="E3rxu"></a>
  2. ### 6、方法重载
  4. - 方法重载：在同一个类里，多个方法的方法名一致，形参列表不一致（包含形参类型，顺序，个数）
  5. - 形参名不参与比较，返回类型不参与比较
  6. - Student(String age){}    Student(String sex){} //不属于方法重载

public class Person {

  1. public String name;
  3. public int age;
  5. public void move(){
  7. }
  9. public void move(String name, int age){
  11. }
  13. public void move(int age, String name){
  15. }

} ```