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 封装

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

2. 面向对象

2.1 面向对象与面向过程

2.2 类和对象

2.3 类的定义

2.4 static关键字

2.5 private关键字

2.6 this关键字

2.7 构造方法

2.8 封装

热门文章

最新文章

相关课程

相关电子书

相关实验场景