面向对象

Posted 2020-10-06

1 面向对象的概念

• 面向对象就是一种常见的思想，符合人们的思考习惯。
• 面向对象的出现，将复杂的问题简单化。
• 面向对象的出现，让曾经在过程中的执行者，变成了对象中的指挥者。

 

• 面向对象的开发、设计和特征
  • 开发：就是不断的创建对象，使用对象和指挥对象做事情。
  • 设计：其实就是管理和维护对象之间的关系。
  • 面向对象的特征：封装、继承和多态　　

 

2 类与对象的关系

• 我们学习编程语言，就是为了模拟现实十几节的事物，实现信息化。比如：去超市买东西的计费系统，去银行办业务的系统。
• 我们是如何表示一个现实世界的事物呢？
  • 属性：就是该事物的描述信息。
  • 行为：就是该事物能够做什么。　　
• Java语言最基本的单位是类，所以，我们就应该把事物用一个类来表示。

 

• 类：是一组相关属性和行为的集合。
• 对象：是该类事物的具体体现。
• 举例：类--学生，对象--班长。

• 类的定义
  • 现实世界的事物
    • 属性  人的身高，体重等。
    • 行为  人学习，吃饭等。　　　　

• Java中用class来描述事物也是如此。
  • 成员变量 ，就是事物的属性。
  • 成员方法 ，就是事物的行为。　　
• 定义类其实就是定义类的成员（成员变量和成员方法）。

 

• 示例：汽车 

package java006;

/**
 * 2017/9/6
 * 说明：汽车类
 */
public class Car {
    int num;//轮胎数
    String color;//颜色

    /**
     * 运行
     */
    public void run(){
        System.out.print(num +""+color);
    }

}

package java006;

/**
 * 2017/9/6
 * 说明：
 */
public class CarTest {
    public static void main(String[] args) {
        Car car = new Car();
        car.num = 4;
        car.color = "红色";

        car.run();
    }
}

• 成员变量和局部变量的区别？
  • ①在类中的位置不同
    • 成员变量定义在类中方法外。
    • 局部变量定义在方法内或者方法声明上。　　　　
  • ②在内存中的位置不同
    • 成员变量，在堆内存。
    • 局部变量，在栈内存。　　　　
  • ③生命周期不同
    • 成员变量，随着对象的存在而存在，随着对象的消失而消失。
    • 局部变量，随着方法的调用而存在，随着方法的调用完毕而消失。　　　　
  • ④初始化值不同
    • 成员变量，有默认的初始化值。
    • 局部变量，没有默认的初始化值，必须先定义，赋值，再使用。　　　　

 

• 解析对象的内存体现
  • 示例：　　

package java006;

/**
 * 2017/9/6
 * 说明：汽车类
 */
public class Car {
    int num;//轮胎数
    String color;//颜色

    /**
     * 运行
     */
    public void run(){
        System.out.print(num +" "+color);
    }

}

package java006;

/**
 * 2017/9/6
 * 说明：
 */
public class CarTest {
    public static void main(String[] args) {
        Car car1 = new Car();
        car1.num = 4;
        car1.color = "红色";

        Car car2 = new Car();
        car2.num = 4;
        car2.color = "黑色";

        car1.run();
        car2.run();
    }
}

 

• • 示例：　　

package java006;

/**
 * 2017/9/6
 * 说明：汽车类
 */
public class Car {
    int num;//轮胎数
    String color;//颜色

    /**
     * 运行
     */
    public void run(){
        System.out.print(num +" "+color);
    }

}

package java006;

/**
 * 2017/9/6
 * 说明：
 */
public class CarTest {
    public static void main(String[] args) {
        Car car1 = new Car();
        car1.num = 4;
        car1.color = "红色";

        Car car2 = car1;

        car1.run();
        car2.run();
    }
}

 

• 匿名对象
  • 定义：就是没有名字的对象，是对象的一种简化表现形式。
  • 使用场景：
    • 对象调用方法仅仅一次的时候。
    • 作为实际参数传递。　　　　
  • 示例1：　　

package java006;

/**
 * 2017/9/6
 * 说明：汽车类
 */
public class Car {
    int num;//轮胎数
    String color;//颜色

    /**
     * 运行
     */
    public void run(){
        System.out.print(num +" "+color);
    }

}

package java006;

/**
 * 2017/9/6
 * 说明：
 */
public class CarTest {
    public static void main(String[] args) {
        Car car1 = new Car();


        new Car().run();
    }
}

• • 示例2：　　

package java006;

/**
 * 2017/9/6
 * 说明：汽车类
 */
public class Car {
    int num;//轮胎数
    String color;//颜色

    /**
     * 运行
     */
    public void run(){
        System.out.print(num +" "+color);
    }

}

package java006;

/**
 * 2017/9/6
 * 说明：
 */
public class CarTest {
    public static void main(String[] args) {

        show(new Car());


    }
    public static void show(Car c){
        c.num = 4;
        c.color = "黑色";
        c.run();
    }
}

 

3 封装

• 封装：是指隐藏对象的属性和实现细节，仅仅对外提供公共访问方式。
• 封装的好处：
  • 将变化隔离。
  • 便于使用。
  • 提高重用性。
  • 提高安全性。　　 
• 封装的原则：
  • 将不需要对外提供的内容都隐藏起来。
  • 把属性都隐藏，提供公共方法对其访问。　　

 

• 示例：

package java006;

/**
 * 2017/9/6
 * 说明：人类
 */
public class Person {
    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age > 0 && age <=200){
            this.age = age;
        }

    }

    public void speak(){
        System.out.print("我的年龄是："+age);
    }

}

package java006;

/**
 * 2017/9/6
 * 说明：
 */
public class PersonTest {
    public static void main(String[] args) {
        Person p = new Person();
        p.setAge(-1);
        p.speak();
    }

}

 

4 构造函数

• 特点：
  • 函数名和类名相同。
  • 不用定义返回值类型，连void都没有。
  • 没有具体的返回值。　　
• 作用：
  • 给对象进行初始化。　
• 注意：
  • 如果你不提供构造方法，系统会给出默认的构造方法。
  • 如果你提供了构造方法，系统就不会再提供。
  • 构造方法时可以重载的。　　

 

• 示例：

package java006;

/**
 * 2017/9/6
 * 说明：人类
 */
public class Person {
    private int age;
    private String name;

    public Person(){

    }

    public Person(String name,int age){
        this.setName(name);
        this.setAge(age);
    }


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age > 0 && age <=200){
            this.age = age;
        }

    }

    public void speak(){
        System.out.print("我的姓名是："+this.name+"我的年龄是："+age);
    }

}

package java006;

/**
 * 2017/9/6
 * 说明：
 */
public class PersonTest {
    public static void main(String[] args) {
        Person p = new Person("张三",26);
        p.speak();
    }

}

 

• 构造函数和一般函数有什么区别？
  • ①
    • 构造函数：创建对象的时候，就会调用与之对应的构造函数，对对象进行初始化。
    • 一般函数：对象创建完毕，需要函数功能的时候才会调用。　　　　
  • ②
    • 构造函数：对象创建的时候，会调用并且只调用一次。
    • 一般函数：对象创建后，可以被调用多次。　　　　

 

5 this关键字

•  this代表其所在函数所属对象的引用。话句话说，this代表的是本类对象的引用。

 

• 什么时候使用this关键字呢？
  • 当在函数内需要用到调用该函数的对象的时候，就用this。
  • 注意的是，方法被那个对象调用，this就代表那个对象。　　

 

• 示例：

package java006;

public class Person {
    private String name;
    private int age;
    
    public Person(String name,int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
    public void speak() {
        System.out.println(name+" "+age);
    }

    
    

}

package java006;

public class PersonTest {
    public static void main(String[] args) {
        Person p = new Person("哈哈",23);
        p.speak();
        
        Person p2 = new Person("呵呵",29);
        p2.speak();
        
    }
}

 

6 static关键字

• static关键字，用于修饰成员（成员变量和成员函数）。
• 被修饰的成员具备以下的特点：
  • ①随着类的加载而加载。
  • ②优先于对象存在。
  • ③被所有对象所共享。
  • ④可以直接被类名调用。　　 
• 注意事项：
  • ①静态方法只能访问静态成员。
  • ②静态方法不可以写this，super关键字。
  • ③主函数是静态的。　　

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

7 单例设计模式