2. 面向对象-阿里云开发者社区

2.1 面向对象与面向过程

什么是面向过程？

面向过程，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。

例如:吃煎饼果子利用面向过程的思想:

学习摊煎饼的技术
买材料鸡蛋,油,葱等等
开始摊
吃
收拾

什么是面向对象？

面向对象思想就是不断的创建对象，使用对象，指挥对象做事情。（如果有对象，直接用对象，对我们直接提供服务）

例如:吃煎饼果子利用面向对象的思想

找会摊煎饼的大妈(创建一个摊煎饼大妈的对象)
调用其摊煎饼的技能(功能),传递进去钱参数
返回给我们一个煎饼
吃

面向对象:着眼点在于找到一个能够帮助解决问题的实体, 然后委托这个实体来解决问题；

面向过程: 着眼点在于问题是怎样一步步的解决的, 然后亲力亲为的去解决这个问题；

Java是一种面向对象的语言:

用Java这门语言, 可以很容易的写出具有面向对象思维方式的代码

用面向对象的编程语言写出的代码, 一定是面向对象的代码? 错!

2.2 类和对象

类：是一组相关的属性和行为的集合（我们班所有的同学都具备相同的属性和行为，比如：姓名，年龄，学习，这样就把所有的学生成为学生类）

对象：是该类事物的具体体现（说某个同学时，他都具备自己特有的属性和行为）

类：学生对象：具体的张三李四就是对象

类：车对象：具体的开的奔驰、宝马，就是对象

2.3 类的定义

定义学生类：

定义成员变量和成员方法，其中成员变量和普通变量的区别是，成员变量是定义类的特征，在类内定义，成员变量是有默认值的（整型: 0，浮点型: 0.0 ，布尔型: false，字符型: '\0' '\u000'，引用数据类型: null）

public class Student {
  //特征：表现为属性，属性有默认值，整型: 0，浮点型: 0.0，布尔型: false
  //字符型: '\0'  '\u000'，引用数据类型: null
  //成员变量
  //姓名
  String name;
  //年龄
  int age;
  //行为：表现出的是方法
  //成员方法
  public void study() {
    System.out.println("好好学习，天天向上");
  }
  public void eat() {
    System.out.println("吃饱了才有力气减肥");
  }
}

类的使用：

public class StudentTest {
  public static void main(String[] args) {
    //创建对象
    //类名  对象名  = new 类名();
    Student s = new Student();
    //使用成员变量
    System.out.println("姓名："+s.name);//null
    System.out.println("年龄："+s.age);//0
    System.out.println("----------");
    //给成员变量赋值
    s.name = "孙俪";
    s.age = 30;
    //再次使用成员变量
    System.out.println("姓名："+s.name);//孙俪
    System.out.println("年龄："+s.age);//30
    System.out.println("----------");
    //调用成员方法
    s.study();
    s.eat();
  }
}

注意事项:

类名是一个标识符, 遵循大驼峰命名法
一个java文件中可以写多个类, 但是只有和文件名相同的那个类名可以修饰为public
在程序编译的时候, 每一个类都会生成一个.class字节码文件, 而且.class文件的名字和类名相同
在程序中, 是先有类, 然后再从这个类中实例化一个对象

2.4 static关键字

static:

用关键字static修饰的成员, 叫做静态成员

没有用关键字static修饰的成员, 叫做非静态成员

静态成员:

静态成员是属于类的, 在访问的时候, 需要用类来访问
静态成员开辟空间, 是在这个类第一次被加载到内存中的时候开辟的

非静态成员:

非静态成员是属于对象的, 在访问的时候, 需要用对象来访问
非静态成员开辟空间, 是在这个对象被实例化的时候开辟的

注意：

静态方法中, 不能直接访问非静态成员
在非静态的方法中, 可以直接访问静态的成员

class Person {
    String name;
    static int a;
    void eat() {}
    static void sleep() {}
}
class Program {
    public static void main(String[] args) {
        Person xiaomin = new Person();
        // 访问非静态成员
        xiaomin.name = "xiaomin";
        xiaomin.eat();
        // 访问静态成员
        Person.a = 10;
        Person.sleep();
        // 注: 
        // 访问静态的成员, 也可以使用对象来访问, 但是会有警告
        // 推荐使用类来访问静态成员
    }
}

2.5 private关键字

private是一个权限修饰符。
private可以修饰成员(成员变量和成员方法)
被private修饰的成员只在本类中才能访问。

public class Student {
  private String name;
  private int age;
  public void setName(String n) {
    name = n;
  }
  public String getName() {
    return name;
  }
  public void setAge(int a) {
    age = a;
  }
  public int getAge() {
    return age;
  }
}
/*
 * 测试类
 */
public class StudentTest {
  public static void main(String[] args) {
    //创建对象
    Student s = new Student();
    System.out.println(s.getName()+"***"+s.getAge());
    //给成员变量赋值
    s.setName("杨幂");
    s.setAge(30);
    System.out.println(s.getName()+"***"+s.getAge());
  }
}

2.6 this关键字

this:代表所在类的对象引用，方法被哪个对象调用，this就代表那个对象；

使用场景：用于解决成员变量被隐藏的问题，也就是局部变量和成员变量重名；

public class Student {
  private String name;
  private int age;
  public void setName(String name) { 
    //name = name;
    this.name = name;
  }
  public String getName() {
    return name;
    //return this.name;
  }
  public void setAge(int age) {
    this.age = age;
  }
  public int getAge() {
    return age;
  }
}
public class StudentTest {
  public static void main(String[] args) {
    // 创建对象
    Student s = new Student();
    System.out.println(s.getName() + "---" + s.getAge());
    s.setName("孙俪");
    s.setAge(30);
    System.out.println(s.getName() + "---" + s.getAge());
  }
}

2.7 构造方法

构造方法作用

创建一个类的对象，并给对象的数据进行初始化

构造方法格式

方法名与类名相同；

没有返回值类型，连void都没有，没有具体的返回值。

public class Student {
  private String name;
  private int age;
  public void setName(String name) { 
    //name = name;
    this.name = name;
  }
  public String getName() {
    return name;
    //return this.name;
  }
  public void setAge(int age) {
    this.age = age;
  }
  public int getAge() {
    return age;
  }
}
public class StudentTest {
  public static void main(String[] args) {
    // 创建对象
    Student s = new Student();
    System.out.println(s.getName() + "---" + s.getAge());
    s.setName("孙俪");
    s.setAge(30);
    System.out.println(s.getName() + "---" + s.getAge());
  }
}

注意：

如果你不提供构造方法，系统会给出默认构造方法；

如果你提供了构造方法，系统将不再提供；

构造方法也是可以重载的,重载条件和普通方法相同。

public class Student {
  private String name;
  private int age;
  public Student() {}
  public Student(String name) {
    this.name = name;
  }
  public Student(int age) {
    this.age = age;
  }
  public Student(String name,int age) {
    this.name = name;
    this.age = age;
  }
  public void show() {
    System.out.println(name+"---"+age);
  }
}
public class StudentTest {
  public static void main(String[] args) {
    //如何调用构造方法呢?
    //其实通过new关键字就可以
    //格式：类名 对象名 = new 构造方法名(...);
    Student s = new Student();
    s.show();
    //public Student(String name)
    Student s2 = new Student("孙俪");
    s2.show();
    //public Student(int age)
    Student s3 = new Student(30);
    s3.show();
    //public Student(String name,int age)
    Student s4 = new Student("孙俪",30);
    s4.show();
  }
}

2.8 封装

封装是面向对象三大特征之一，是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。

封装原则，将不需要对外提供的内容都隐藏起来，把属性隐藏，提供公共方法对其访问，成员变量private，提供对应的getXxx()/setXxx()方法。

封装的好处，通过方法来控制成员变量的操作，提高了代码的安全性，把代码用方法进行封装，提高了代码的复用性。

2. 面向对象

2.1 面向对象与面向过程

2.2 类和对象

2.3 类的定义

2.4 static关键字

2.5 private关键字

2.6 this关键字

2.7 构造方法

2.8 封装

热门文章

最新文章

相关课程

相关电子书

相关实验场景