200-Java语言基础-Java编程入门-007 | Java面向对象（一）- 类与对象概述

一、面向对象思想概述

面向对象思想特点：

• 是一种更符合我们思想习惯的思想
• 可以将复杂的事情简化
• 将我们从执行者变成了指挥者
• 角色发生了转换

面向对象开发：

• 就是不断的创建对象、使用对象、指挥对象做事情

面向对象设计：

• 其实就是在管理和维护对象之间的关系

面向对象的特征：

• 封装（encapsulation）
• 继承（inheritance）
• 多态（polymorphism）

二、类与对象概述

我们学习编程是为了什么：

• 为了把我们日常生活中实物用学习语言描述出来

我们如何描述现实世界事物：

• 属性：就是该事物的描述信息(事物身上的名词)
• 行为： 就是该事物能够做什么(事物身上的动词)

Java中最基本的单位是类,Java中用class描述事物也是如此：

• 成员变量：就是事物的属性
• 成员方法：就是事物的行为

定义类其实就是定义类的成员(成员变量和成员方法)：

• 成员变量：和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。
• 成员方法：和以前定义方法是一样的，只不过把static去掉，后面在详细讲解static的作用。

类和对象的概念：

• 类：是一组相关的属性和行为的集合
• 对象：是该类事物的具体体现
• 举例：
• 类     学生
• 对象    具体的某个学生就是一个对象

1、学生类的定义

class JavaDemo {
  public static void main(String[] args) {
    
  }
}
/*
   * A:案例演示
     * 属性:姓名,年龄,性别
     * 行为:学习,睡觉
   * B:我们如何描述现实世界事物
     * 属性  就是该事物的描述信息(事物身上的名词)
     * 行为  就是该事物能够做什么(事物身上的动词)
   * C:Java中最基本的单位是类,Java中用class描述事物也是如此
     * 成员变量  就是事物的属性
     * 成员方法  就是事物的行为
   * D:定义类其实就是定义类的成员(成员变量和成员方法)
     * a:成员变量  和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。
     * b:成员方法  和以前定义方法是一样的，只不过把static去掉，后面在详细讲解static的作用。
   */
class Student {
  String name;          // 姓名
  int age;              // 年龄
  String gender;        // 性别
  
  public void study() { // 定义学习的方法
    System.out.println("学生学习");
  }
  
  public void sleep() { // 定义睡觉的方法
    System.out.println("学生睡觉");
  }
}

1.1、学生类的使用

/*
* A:文件名问题
   * 在一个java文件中写两个类：一个基本的类，一个测试类。
   * 建议：文件名称和测试类名称一致。
* B:如何使用对象?
   * 创建对象并使用
   * 格式：类名 对象名 = new 类名();
* D:如何使用成员变量呢?
   * 对象名.变量名
* E:如何使用成员方法呢?
   * 对象名.方法名(...)
*/
class JavaDemo {
  public static void main(String[] args) {
    // 创建对象并使用 格式：类名 对象名 = new 类名();
    // 对象名：其实就是合法的标识符，如果一个单词所有字母小写；如果多个单词，从第二个单词开始首字母大写
    Student student = new Student();
    // 如何使用成员变量呢?
    // 对象名.变量名
    student.name = "张三";
    student.age = 18;
    student.gender = "男";
    System.out.println(student.name + "..." + student.age + "..." +  student.gender);
    // 如何使用成员方法呢?
    // 对象名.方法名(...)
    student.study();
    student.sleep();
  }
}
/*
* A:案例演示
   * 属性:姓名,年龄,性别
   * 行为:学习,睡觉
* B:我们如何描述现实世界事物
   * 属性  就是该事物的描述信息(事物身上的名词)
   * 行为  就是该事物能够做什么(事物身上的动词)
* C:Java中最基本的单位是类,Java中用class描述事物也是如此
   * 成员变量  就是事物的属性
   * 成员方法  就是事物的行为
* D:定义类其实就是定义类的成员(成员变量和成员方法)
   * a:成员变量  和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。
   * b:成员方法  和以前定义方法是一样的，只不过把static去掉，后面在详细讲解static的作用。
*/
class Student {
  String name;          // 姓名
  int age;              // 年龄
  String gender;        // 性别
  
  public void study() { // 定义学习的方法
    System.out.println("学生学习");
  }
  
  public void sleep() { // 定义睡觉的方法
    System.out.println("学生睡觉");
  }
}

2、手机类的定义

class JavaDemo {
  public static void main(String[] args) {
    System.out.println("Hello World");
  }
}
/*
* 模仿学生类，让学生自己完成
   * 属性:品牌(brand)价格(price)
   * 行为:打电话(call),发信息(sendMessage)玩游戏(playGame)
*/
class Phone {
  String brand;          // 品牌
  int price;             // 价格
  
  // 定义打电话的方法
  public void call() {
    System.out.println("打电话");
  }
  
  // 定义发信息的方法
  public void sendMessage() {
    System.out.println("发信息");
  }
  
  // 定义玩游戏的方法
  public void playGame() {
    System.out.println("玩游戏");
  }
}
 
2.1、手机类的使用
class JavaDemo {
  public static void main(String[] args) {
    // 创建对象
    Phone p = new Phone();
    // 调用成员变量
    p.brand = "iphone";
    p.price = 8888;
    System.out.println(p.brand + "..." + p.price);
    // 调用成员方法
    p.call();
    p.sendMessage();
    p.playGame();
        
  }
}
/*
* 手机类
   * 属性:品牌(brand)价格(price)
   * 行为:打电话(call),发信息(sendMessage)玩游戏(playGame)
*/
class Phone {
  String brand;          // 品牌
  int price;             // 价格
  
  // 定义打电话的方法
  public void call() {
    System.out.println("打电话");
  }
  
  // 定义发信息的方法
  public void sendMessage() {
    System.out.println("发信息");
  }
  
  // 定义玩游戏的方法
  public void playGame() {
    System.out.println("玩游戏");
  }
}

 

三、对象的内存图

1、一个对象的内存图

class JavaDemo {
  public static void main(String[] args) {
    Car c1 = new Car();
    
    // 调用成员变量并赋值
    c1.color = "red";
    c1.num = 4;
    
    // 调用成员方法
    c1.run();
  }
}
/*
* 车类
   * 属性:颜色、轮胎数
   * 行为:车运行
*/
class Car {
  String color;          // 颜色
  int num;               // 轮胎数
  
  // 定义车运行的方法
  public void run() {
    System.out.println(color + "..." + num);
  }
}

2、二个对象的内存图

class JavaDemo {
  public static void main(String[] args) {
    Car c1 = new Car();
    
    // 调用成员变量并赋值
    c1.color = "red";
    c1.num = 4;
    
    // 调用成员方法
    c1.run();
    
    Car c2 = new Car();
    
    // 调用成员变量并赋值
    c2.color = "black";
    c2.num = 8;
    
    // 调用成员方法
    c2.run();
    
    // 用null把原来的地址值覆盖掉了
    c2 = null;
    // c2里面记录的是null，所以报出了空指针异常
    c2.run();
  }
}
/*
* 车类
   * 属性:颜色、轮胎数
   * 行为:车运行
*/
class Car {
  String color;          // 颜色
  int num;               // 轮胎数
  
  // 定义车运行的方法 
  public void run() {
    System.out.println(color + "..." + num);
  }
}

3、三个引用两个对象的内存图

class JavaDemo {
  public static void main(String[] args) {
    Car c1 = new Car();
    
    // 调用成员变量并赋值
    c1.color = "red";
    c1.num = 4;
    
    // 调用成员方法
    c1.run();
    
    Car c2 = new Car();
    
    // 调用成员变量并赋值
    c2.color = "black";
    c2.num = 8;
    
    // 调用成员方法
    c2.run();
    
    Car c3 = c2;
    c3.run();
  }
}
/*
* 车类
   * 属性:颜色、轮胎数
   * 行为:车运行
*/
class Car {
  String color;          // 颜色
  int num;               // 轮胎数
  
  // 定义车运行的方法
  public void run() {
    System.out.println(color + "..." + num);
  }
}

 

三、成员变量和局部变量的区别

在类中的位置不同：

• 成员变量：在类中方法外
• 局部变量：在方法定义中或者方法声明上

在内存中的位置不同：

• 成员变量：在堆内存(成员变量属于对象,对象进堆内存)
• 局部变量：在栈内存(局部变量属于方法,方法进栈内存)

生命周期不同：

• 成员变量：随着对象的创建而存在，随着对象的消失而消失
• 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

初始化值不同：

• 成员变量：有默认初始化值
• 局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。

注意事项：

• 部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
• 基本数据类型变量包括哪些:byte,short,int,long,float,double,boolean,char
• 引用数据类型变量包括哪些:数组,类,接口,枚举

class JavaDemo {
  public static void main(String[] args) {
    Person p = new Person();
    p.speak(10);
  }
}
/*
* A:在类中的位置不同
   * 成员变量：在类中方法外
   * 局部变量：在方法定义中或者方法声明上
* B:在内存中的位置不同
   * 成员变量：在堆内存(成员变量属于对象,对象进堆内存)
   * 局部变量：在栈内存(局部变量属于方法,方法进栈内存)
* C:生命周期不同
   * 成员变量：随着对象的创建而存在，随着对象的消失而消失
   * 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
* D:初始化值不同
   * 成员变量：有默认初始化值
   * 局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。
   
* 注意事项：
   * 局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
   * 基本数据类型变量包括哪些:byte,short,int,long,float,double,boolean,char
   * 引用数据类型变量包括哪些:数组,类,接口,枚举
*/
class Person {
  // 成员变量
  String name;
  int num;
  public void speak(int x) {
    // x和num都是局部变量
    int num = 10;
    System.out.println(name);
    System.out.println(num);
  }
}

 

四、方法的形式参数是类名的时候如何调用

class JavaDemo {
  public static void main(String[] args) {
    print(10);
    // 创建对象，并将对象的地址赋值给s
    Student s = new Student();
    print(s);
  }
  
  // 基本数据类型当作形式参数
  public static void print(int x) {
    System.out.println(x);
  }
  
  //引用数据类型当作形式参数
   public static void print(Student stu) {
     stu.name = "张三";
     stu.age = 23;
     stu.speak();
   }
}
/*
* A:方法的参数是类名public void print(Student s){}//print(new  Student());
   * 如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。
*/
class Student {
  // 成员变量
  String name;
  int age;
  public void speak() {
    System.out.println(name + "..." + age);
  }
}

 

五、匿名对象的概述和应用

什么是匿名对象：

• 没有名字的对象

匿名对象应用场景：

• 调用方法，仅仅只调用一次的时候。
• 那么，这种匿名调用有什么好处吗?
• 节省代码
• 注意：调用多次的时候，不适合。匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
• 匿名对象可以作为实际参数传递

/*
* A:什么是匿名对象
   * 没有名字的对象
* B:匿名对象应用场景
   * a:调用方法，仅仅只调用一次的时候。
     * 那么，这种匿名调用有什么好处吗?
       * 节省代码
     * 注意：调用多次的时候，不适合。匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
   * b:匿名对象可以作为实际参数传递
* C:案例演示
   * 匿名对象应用场景
*/
class JavaDemo {
  public static void main(String[] args) {
    /*
    // 创建有名字的对象
   Car c1 = new Car();
   c1.run();
   
   // 匿名对象调用方法
   new Car().run();
   // 匿名对象只适合对方法的一次调用，因为调用多次就会产生多个对象，不如用有名的对象
   new Car().run();
   */
    
    // 匿名对象是否可以调用属性并赋值？有什么意义
    /*
     * 匿名对象可以调用属性，但是没有意义，因为调用后就变成垃圾
     * 如果需要赋值还是使用有名字的对象
     */
    new Car().clor = "red";
    new Car().num = 4;
    new Car().run();   // null...0运行
  }
}
class Car {
  // 成员变量
  String clor;
  int num;
  public void run() {
    System.out.println(clor + "..." + num + "运行");
  }
}
/*
* A:什么是匿名对象
   * 没有名字的对象
* B:匿名对象应用场景
   * a:调用方法，仅仅只调用一次的时候。
     * 那么，这种匿名调用有什么好处吗?
       * 节省代码
     * 注意：调用多次的时候，不适合。匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
   * b:匿名对象可以作为实际参数传递
* C:案例演示
   * 匿名对象应用场景
*/
class JavaDemo {
  public static void main(String[] args) {
    // 创建有名字的对象
    // Car c1 = new Car();
    // method(c1);
    method(new Car());
    // Car c2 = new Car();
    // method(c2);
    method(new Car());             // 匿名对象可以当做参数传递
  }
  // 抽取方法提高代码的复用性
  public static void method (Car cc) {
    cc.clor = "red";
    cc.num = 4;
    cc.run();
  }
}
class Car {
  // 成员变量
  String clor;
  int num;
  public void run() {
    System.out.println(clor + "..." + num + "运行");
  }
}

五、封装的概述

封装概述：

• 是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

封装好处：

• 隐藏实现细节，提供公共的访问方式
• 提高了代码的复用性
• 提高安全性。

封装原则：

• 将不需要对外提供的内容都隐藏起来。
• 把属性隐藏，提供公共方法对其访问。

 

1、private关键字的概述和特点

private关键字特点：

• 是一个权限修饰符
• 可以修饰成员变量和成员方法
• 被其修饰的成员只能在本类中被访问

/*
* :人类赋值年龄的问题
* B:private关键字特点
   * a:是一个权限修饰符
   * b:可以修饰成员变量和成员方法
   * c:被其修饰的成员只能在本类中被访问
* C:案例演示
   * 封装和private的应用：
   * A:把成员变量用private修饰
   * B:提供对应的getXxx()和setXxx()方法
   * private仅仅是封装的一种体现形式,不能说封装就是私有
*/
class JavaDemo {
  public static void main(String[] args) {
    Person p1 = new Person();
    p1.name = "张三";
    // p1.age = -23;
    // p1.speak();
    p1.setAge(23);
    System.out.println(p1.getAge());
  }
}
class Person {
  // 成员变量
  String name;
  private int age;
  
  // 获取年龄
  public int getAge() {
    return age;
  }
  // 设置年龄
  public void setAge(int age) {
    if (age > 0 && age < 200) {
      age = age;
    } else {
      System.out.println("哈哈哈");
    }
    
  }
  public void speak() {
    System.out.println(name + "..." + age);
  }
}

2、this关键字的概述和应用

this关键字特点：

• 代表当前对象的引用

/*
* A:this关键字特点
   * 代表当前对象的引用
* B:案例演示
   * this的应用场景
   * 用来区分成员变量和局部变量重名
*/
class JavaDemo {
  public static void main(String[] args) {
    Person p1 = new Person();
    p1.setName("张三");
    p1.setAge(23);
    System.out.println(p1.getName() + "..." + p1.getAge());
    
    Person p2 = new Person();
    p2.setName("李四");
    p2.setAge(18);
    System.out.println(p2.getName() + "..." + p2.getAge());
  }
}
class Person {
  // 成员变量
  private String name;
  private int age;
  
  // 获取年龄
  public int getAge() {
    return age;
  }
  // 设置年龄
  public void setAge(int age) {
    if (age > 0 && age < 200) {
      this.age = age;
      // System.out.println(age);
    } else {
      System.out.println("哈哈哈");
    }
    
  }
  //获取姓名
  public String getName() {
    return name;
  }
  //设置姓名
  public void setName(String name) {
    this.name = name;
    // System.out.println(name);
  }
  public void speak() {
    System.out.println(name + "..." + age);
  }
}