面向对象基础

面向对象基础

一、类和对象

1.1面向对象思想

面向对象编程（Object Oriented Programming）

面向过程与面向对象比较

• 面向过程
  • 着重于过程
  • 优点：性能高
  • 缺点：耦合性高 不易于扩展与维护
• 面向对象
  • 着重于对象
  • 优点：耦合性低，易于扩展、维护
  • 缺点：性能低

1.2什么是程序

• 程序是为了解决现实世界的问题 模拟现实世界
• 在java中，世界是由对象组成的

1.3、什么是对象

• 一切客观存在的事物（一辆车、一本书、一个人）都是对象，万事万物皆对象；

• 任何对象，一定具有自己的特征和行为。

  • 特征：称为属性一般为名词，代表对象有什么
  • 行为：称为方法，一般为动词，代表对象能做什么

对象是实际存在的该类事务的每个个体，因而也称实例(instance)。

1.4什么是类

类是对一类事物描述，是抽象的、概念上的定义。

类可以看成是创建Java对象的模板

1.5为什么设计类

基本数据类型无法满足程序设计的要求，我们需要自定义类型满足程序设计的要求，类其实就是一种自定义的类型。

二、类的组成

2.1创建类

[修饰符] class 类名 {
    属性
    [构造方法]
    方法    
}

• 修饰符：可以省略

• 类名：要符合标识符的命名规范。

• 属性描述了类描述的事物所具有的特性，代表有什么。

• 方法描述了类描述的事物所具有的动作，代表能做什么。

public class Dog {
    //成员属性 实例变量 成员变量
    String name;
    String color;
    double age;
    String sex;

    //成员方法
    public void eat(){
        System.out.println("汪汪汪");
    }
    
    public void lookHome(){
        System.out.println("狗会看家");
    }

}

2.2属性

[修饰符] 数据类型 属性名 [= 初始值];

修饰符：可以省略，目前我们暂时填写public；

数据类型：任意的数据类型，可以是基本数据类型也可以是引用数据类型；

属性名：属性的名字，要符合标识符的命名规范；

初始值：在设计类时，可以为属性指定初始值，也可以不指定初始值，如果不指定，那么属性有默认的初始值。

属性有时也被称为：成员变量，数据成员。

2.3方法

[修饰符] 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2…) {
    方法体;
    return 返回值;
}

修饰符：比较多，后面会详细介绍。目前我们暂时填写public；

方法名：一个名字，为了方便我们调用方法，要符合标识符的命名规范，见名知意；

参数类型：限定调用方法时传入参数的数据类型；

参数名：接收调用方法时传入的参数，要符合标识符的命名规范，见名知意；

方法体：完成功能的代码；

return：结束方法以及返回方法指定类型的值；

返回值类型：用于限定返回值的数据类型。如果没有返回值，返回值类型为void，此时return语句有如下两种写法：

• return;

• 可以不写return语句

返回值，程序被return带回的结果，返回给调用者。

三、对象的创建和使用

使用new关键字创建一个新的对象；

使用对象名.对象成员的方式访问对象成员（包括属性和方法）；

如果创建了一个类的多个对象，对于类中定义的属性，每个对象都拥有各自的一套副本，且互不干扰；

对象创建后，属性会被赋初值，默认的初始值如下：

• 存放基本数据类型数据成员变量的初始值
  • int：0
  • byte：0
  • short：0
  • long：0
  • float：0.0
  • double：0.0
  • char：'\u0000'
  • boolean：false
• 存放引用数据类型数据成员变量的初始值：null

package com;

public class Demo {
    public static void main(String[] args) {
        //创建对象
        Dog dog = new Dog();


        //调用属性
        dog.name="xxx";
        dog.color="yellow";
        dog.sex="公";
        dog.age=10;


        System.out.println(dog.name);
        System.out.println(dog.color);
        System.out.println(dog.sex);
        System.out.println(dog.age);


        //调用方法  ta的行为
        dog.cry();
        dog.houseKeeping();


        System.out.println("+++++++++++++++++++++++++++++++");
        //对象可以创建多个
        Dog dog1 = new Dog();
        Dog dog2 = new Dog();

        dog1.name="aaa";
        dog1.color="blue";
        dog1.sex="母";
        dog1.age=10;

        System.out.println(dog1.name);
        System.out.println(dog1.color);
        System.out.println(dog1.sex);
        System.out.println(dog1.age);

        dog1.cry();
        dog2.cry();

    }
}

四、类和对象的关系

• 类：定义了对象应该具有的特征和行为、类是对象的模板
• 对象：拥有多个相同特征和行为的实体，对象是类的实例
• 面向对象就是从具体到抽象，再从抽象到具体的过程
• 类是对象的模板，对象是类的实例

五、成员变量和局部变量

	成员变量	局部变量
定义位置	类的内部，方法的外部（在类中）	方法或方法内的代码块中
默认值	有默认值，和数组元素默认值相同	没有默认值
生命周期	成员变量随着对象的创建而初始化，随着对象的消失而消失	局部变量随着方法区域的执行而初始化，随着方法区域的结束而释放
作用域	成员变量定义在类中，整个类中都可以使用	局部变量定义在方法代码块中，只在所属的区域有效
重名问题	不能重名	在作用域不同时可以重名

**注意：**当局部变量和成员变量重名时，java遵循就近原则

六、实例方法（成员方法）

6.1实例方法（成员方法）

• 实例方法当对象被创建时候产生（不使用static修饰）

6.2方法的重载

• 在一个类中出现同名不同参的方法称为方法重载
• 方法重载要求：
  1. 同名不同参
  2. 与修饰符 返回值无关

public class Person {
	public String name;// 姓名
	public int age;// 年龄
	public String gender;// 性别
	public String id;// 身份证号
	public String tel;// 电话

	// 跑步
	public void running() {
		/*
		 * 类中的方法可以直接访问类的属性
		 */
		System.out.println(name + " running....");
	}

	// 学习 方法重载
	public void learn() {
		System.out.println("learn....");
	}
    
    // 方法重载
   	public void learn(String subject) {
        System.out.println("learn..." + subject);
    }
}

测试

public class Demo {
    public static void main(String[] args) {
        //创建对象
        Person p1 = new Person();
        //调用方法
        p1.learn();
        //调用方法
        p1.learn("JavaSE");
    }
}

七、构造方法

7.1构造方法概念

• 类中的特殊方法，主要用于创建对象，在对象创建时被调用
• 作用：
  • 创建类的对象的对象实例化
• 特点：
  • 方法名与类名相同
  • 不用定义返回值类型
  • 没有具体的返回值

7.2构造方法使用及细节

1. 不管有没有显式定义构造方法，创建对象都必须要通过构造方法初始化
2. 一个类中如果没有定义过构造方法，那么该类中会有一个默认的空参数构造方法
3. 如果在类中定义了有参的构造方法，那么类中的默认构造方法会被覆盖，如果此时需要使用无参的构造方法，则要手动定义
4. 构造方法可以有多个，用于对不同的对象进行针对性的初始化；
5. 多个构造方法在类中是以重载的形式来体现的

public class Person {
	public String name;// 姓名
	public int age;// 年龄----私有的
	public String gender;// 性别
	public String id;// 身份证号
	public String tel;// 电话

	/*	构造方法
	 * 	1.方法名和类名相同
	 * 	2.不用定义返回值类型
	 * 	3.在对象被创建的时候调用
	 * 	4.不管有没有定义构造方法，创建对象时都会调用构造方法进行初始化
	 * 	5.如果一个类中没有定义构造方法，那么该类中存在默认的无参的构造方法
	 * 		public Person() {
	 * 
	 * 		}
	 *  6.如果在类中自定义了构造方法，那么默认的构造方法会被覆盖
	 *  	如果想使用默认的构造方法要如何做？----自己手写一个默认的构造方法
	 * */
	/*public Person() {
		System.out.println("创建Person对象");
	}*/
	/*
	 * 默认的构造方法
	 * */
	public Person() {
		
	}
	/*
	 * 带参数的构造方法
	 * */
    public Person(String n) {
        name = n;
    }

    //带参数的构造方法
    public Person(String n, int a, String g, String i, String t) {
        name = n;
        age = a;
        gender = g;
        id = i;
        tel = t;
    }

}

测试

public class Demo {
    public static void main(String[] args) {
        Person p= new Person("张三");
        System.out.println(p.name);

        Person p1 = new Person("ls", 20, "男", "111", "1111");
        System.out.println(p1.name);
        System.out.println(p1.age);
        System.out.println(p1.gender);
        System.out.println(p1.id);
        System.out.println(p1.tel);
    }
}

7.3对象在内存中的创建

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4pgUmtKH-1666399174949)(D:\Folder\笔记\img\对象在内存中的创建.png)]

八、this关键字

功能：

• 表示当前对象；
• 表示构造方法

8.1表示当前类的对象/表示当前构造方法

• this可以调用本类的属性，当成员变量和局部变量重名，用关键字this来区分

  • 语法：this.成员变量名

• this可以调用本类方法

  • 语法：this.方法名
  • 注意：
    • 要在第一行调用，this可以省略

• this也可以调用本类的构造方法，用于在构造函数中调用其他构造函数。

  • 语法：this(参数)
  • 注意：
    1. 只能定义在构造函数的第一行
    2. 避免无限调用

public class Person {
    public String name;// 姓名
    public int age;// 年龄
    public String gender;// 性别
    public String id;// 身份证号
    public String tel;// 电话

    //默认的构造方法 - 没有参数
    public Person() {
    }

    //带参数的构造方法
    /*
    *   如果定义了带参数的构造方法，则默认的无参构造方法会被覆盖(此时默认的无参构造方法无法使用)
    *   此时如果希望试用无参的构造方法，需要手动定义
    * */

    
    
    //带参数的构造方法
    //当成员变量和局部变量重名，可以用关键字this来区分
    public Person(String name) {
        this.name = name;
    }

    public Person(String name, int age) {
        //this用于在构造函数中调用其他构造函数
        //this();不能这样写，避免无限调用
        this(name);
        this.age = age;
    }

    public Person(String name, int age, String gender) {
        //this用于在构造函数中调用其他构造函数
        this(name, age);
        this.gender = gender;
    }

    public Person(String name, int age, String gender, String id) {
        //this用于在构造函数中调用其他构造函数
        this(name, age, gender);
        this.id = id;
    }

    //带参数的构造方法
    public Person(String name, int age, String gender, String id, String tel) {
        //this用于在构造函数中调用其他构造函数
        this(name, age, gender, id);
        this.tel = tel;
    }

    // 跑步
    public void running() {
        /*
         * 类中的方法可以直接访问类的属性
         */
        System.out.println(this.name + " running....");
    }

    // 学习 - 方法重载
    public void learn() {
        System.out.println("learn....");
    }

    // 学习 - 方法重载
    public void learn(String subject) {
        System.out.println("learn..." + subject);
    }
}
```java

调用其他构造函数
        this(name, age, gender, id);
        this.tel = tel;
    }

    // 跑步
    public void running() {
        /*
         * 类中的方法可以直接访问类的属性
         */
        System.out.println(this.name + " running....");
    }

    // 学习 - 方法重载
    public void learn() {
        System.out.println("learn....");
    }
    ```

    // 学习 - 方法重载
    public void learn(String subject) {
        System.out.println("learn..." + subject);
    }
}