面向对象学习的三条主线：

1.Java类及类的成员：属性、方法、构造器；代码块、内部类。

2.面向对象的大特征：封装性、继承性、多态性、(抽象性)。

3.其它关键字：this、super、static、final、abstract、interface、package、import等。

一、类和对象

Java类及类的成员：属性、方法、构造器；代码块、内部类

1、面向对象中两个重要的概念：

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

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

面向对象程序设计的重点是类的设计

设计类，就是设计类的成员。

2、完成一个项目（或功能）的思路：

根据问题需要，选择问题所针对的现实世界中的实体。

从实体中寻找解决问题相关的属性和功能，这些属性和功能就形成了概念世界中的类。把抽象的实体用计算机语言进行描述，形成计算机世界中类的定义。即借助某种程序语言，把类构造成计算机能够识别和处理的数据结构。

将类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具。

3、二者的关系

对象，是由类new出来的，派生出来的。

4、面向对象思想落地实现的规则

1.创建类，设计类的成员。

2.创建类的对象。

3.通过“对象.属性”或“对象.方法”调用对象的结构。

补充：几个概念的使用说明

属性 = 成员变量 = field = 域、字段

方法 = 成员方法 = 函数 = method

创建类的对象 = 类的实例化 = 实例化类

5、对象的创建及内存解析

典型代码：

创建对象语法： 类名对象名 = new 类名();

Person p1 = new Person();
Person p2 = new Person();
Person p3 = p1;//没有新创建一个对象，共用一个堆空间中的对象实体。

说明：如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static的）

意味着：如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。

内存解析:

二、类的结构：属性、方法、构造器

1、属性

语法格式：修饰符数据类型属性名 = 初始化值 ;

对比：属性 vs 局部变量

相同点：

定义变量的格式：数据类型变量名 = 变量值。

先声明，后使用。

变量都其对应的作用域。

不同点：

1、在类中声明的位置的不同

属性：直接定义在类的一对{}内

局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量

2、关于权限修饰符的不同

属性：可以在声明属性时，指明其权限，使用权限修饰符。

常用的权限修饰符：private、public、缺省、protected —>封装性

局部变量：不可以使用权限修饰符。

3、默认初始化值的情况：

属性：类的属性，根据其类型，都默认初始化值。

整型（byte、short、int、long：0）

字符型（char：0 （或’\u0000’））

布尔型（boolean：false）

引用数据类型（类、数组、接口：null）

局部变量：没默认初始化值。

意味着，我们在调用局部变量之前，一定要显式赋值。

特别地：形参在调用时，我们赋值即可。

4、在内存中加载的位置：

属性：加载到堆空间中（非static）

局部变量：加载到栈空间

在方法体外，类体内声明的变量称为成员变量。

在方法体内部声明的变量称为局部变量。

2、方法

2.1、方法的定义

方法是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中
也称为函数或过程。

将功能封装为方法的目的是，可以实现代码重用，简化代码。

Java里的方法不能独立存在，所有的方法必须定义在类里。

比如：Math类：sqrt()\random() …

Scanner类：nextXxx() …

Arrays类：sort() \ binarySearch() \ toString() \ equals() \ …

2.2、方法的重载

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数

类型不同即可。

重载的特点：

与返回值类型无关，只看参数列表，且参数列表必须不同。 (参数个数或参数类

型)。调用时，根据方法参数列表的不同来区别。

重载示例：

//返回两个整数的和

int add(int x,int y){return x+y;}

//返回三个整数的和

int add(int x,int y,int z){return x+y+z;}

//返回两个小数的和

double add(double x,double y){return x+y;}

public class PrintStream {
    public static void print(int i) {……}
    public static void print(float f) {……}
    public static void print(String s) {……}
    public static void main(String[] args) {
        print(3);
        print(1.2f);
        print("hello!");
    }
}

2.3、可变个数的形参

JavaSE 5.0 中提供了Varargs(variable number of arguments)机制，允许直接定

义能和多个实参相匹配的形参。从而，可以用一种更简单的方式，来传递个数可

变的实参。

//JDK 5.0以前： 采用数组形参来定义方法，传入多个同一类型变量
public static void test(int a ,String[] books);
//JDK5.0： 采用可变个数形参来定义方法，传入多个同一类型变量
public static void test(int a ,String…books);

举例：

  public void test(String[] msg){
        System.out.println(“含字符串数组参数的test方法 ");
    }
    public void test1(String book){
        System.out.println(“****与可变形参方法构成重载的test1方法****");
    }
    public void test1(String ... books){
        System.out.println("****形参长度可变的test1方法****");
    }
    public static void main(String[] args){
        TestOverload to = new TestOverload();
//下面两次调用将执行第二个test方法
        to.test1();
        to.test1("aa" , "bb");
//下面将执行第一个test方法
        to.test(new String[]{"aa"});
    }

2.4、方法参数的值传递机制

方法，必须由其所在类或对象调用才有意义。若方法含有参数：

形参：方法声明时的参数。

实参：方法调用时实际传给形参的参数值。

public class ValueTransferTest {
  public static void main(String[] args) {
    System.out.println("***********基本数据类型：****************");
    int m = 10;
    int n = m;
    System.out.println("m = " + m + ", n = " + n);
    n = 20;
    System.out.println("m = " + m + ", n = " + n);
    System.out.println("***********引用数据类型：****************");
    Order o1 = new Order();
    o1.orderId = 1001;
    Order o2 = o1;//赋值以后，o1和o2的地址值相同，都指向了堆空间中同一个对象实体。
    System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
    o2.orderId = 1002;
    System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
  }
}
class Order{
  int orderId;
}

基本数据类型：*****

m = 10, n = 10

m = 10, n = 20

引用数据类型：*****

o1.orderId = 1001,o2.orderId = 1001

o1.orderId = 1002,o2.orderId = 1002

Java的实参值如何传入方法呢？

Java里方法的参数传递方式只有一种：值传递。即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。

形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参。

形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参。

3、构造器

语法格式：

修饰符类名 (参数列表) {

初始化语句；

}

3.1、构造器的特征

它具有与类相同的名称
它不声明返回值类型。（与声明为void不同）
不能被static、 final、 synchronized、 abstract、 native修饰，不能有return语句返回值

3.2、构造器的作用：

创建对象；给对象进行初始化。

如： Order o = new Order(); Person p = new Person(“Peter”,15);

如同我们规定每个“人”一出生就必须先洗澡，我们就可以在“人” 的构造器中加入完成“洗澡”的程序代码，于是每个“人”一出生就会自动完成“洗澡”，程序就不必再在每个人刚出生时一个一个地告诉他们要“洗澡”了。

public class Animal {
    private int legs;
    // 构造器
    public Animal() {
        legs = 4;
    }
    public void setLegs(int i) {
        legs = i;
    }
    public int getLegs() {
        return legs;
    }
}

创建Animal类的实例： Animal a = new Animal(); 调用构造器，将legs初始化为4。

根据参数不同，构造器可以分为如下两类：

隐式无参构造器（系统默认提供）

显式定义一个或多个构造器（无参、有参）

注意：

Java语言中，每个类都至少有一个构造器。

默认构造器的修饰符与所属类的修饰符一致。

一旦显式定义了构造器，则系统不再提供默认构造器。

一个类可以创建多个重载的构造器。

父类的构造器不可被子类继承。

3.3、构造器重载

构造器一般用来创建对象的同时初始化对象。如

class Person{
  String name;
  int age;
  public Person(String n , int a){ name=n; age=a;}
}

构造器重载使得对象的创建更加灵活，方便创建各种不同的对象。

构造器重载举例：

public class Person{
public Person(String name, int age, Date d) {this(name,age);…}
public Person(String name, int age) {…}
public Person(String name, Date d) {…}
public Person(){…}
}

构造器重载，参数列表必须不同。

三、封装与隐藏

我们程序设计追求“高内聚，低耦合”。

高内聚：类的内部数据操作细节自己完成，不允许外部干涉；

低耦合：仅对外暴露少量的方法用于使用。

隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提

高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露

的暴露出来。这就是封装性的设计思想。

1、信息的封装和隐藏

Java中通过将数据声明为私有的(private)，再提供公共的（ public）

方法:getXxx()和setXxx()实现对该属性的操作，以实现下述目的：

隐藏一个类中不需要对外提供的实现细节；

使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，

限制对属性的不合理操作；

便于修改，增强代码的可维护性。

public class AnimalTest {
  public static void main(String[] args) {
    Animal a = new Animal();
    a.name = "大黄";
//    a.age = 1;
//    a.legs = 4;//The field Animal.legs is not visible
    a.show();
//    a.legs = -4;
//    a.setLegs(6);
    a.setLegs(-6);
//    a.legs = -4;//The field Animal.legs is not visible
    a.show();
    System.out.println(a.name);
  }
}
class Animal{
  String name;
  private int age;
  private int legs;//腿的个数
  //对属性的设置
  public void setLegs(int l){
    if(l >= 0 && l % 2 == 0){
      legs = l;
    }else{
      legs = 0;
//      抛出一个异常（暂时没有讲）
    }
  }
  //对属性的获取
  public int getLegs(){
    return legs;
  }
  public void eat(){
    System.out.println("动物进食");
  }
  public void show(){
    System.out.println("name = " + name + ",age = " + age + ",legs = " + legs);
  }
  //提供关于属性age的get和set方法
  public int getAge(){
    return age;
  }
  public void setAge(int a){
    age = a;
  }
}

2、四种访问权限修饰符

Java权限修饰符public、 protected、 (缺省)、 private置于类的成员定义前，用来限定对象对该类成员的访问权限。

对于class的权限修饰只可以用public和default(缺省)。

public类可以在任意地方被访问。
default类只可以被同一个包内部的类访问。

本系列文章参考尚硅谷课程。

【Java基础】——面向对象:封装

一、类和对象

二、类的结构：属性、方法、构造器

1、属性

2、方法

2.1、方法的定义

2.2、方法的重载

2.3、可变个数的形参

2.4、方法参数的值传递机制

3、构造器

3.1、构造器的特征

3.2、构造器的作用：

3.3、构造器重载

三、封装与隐藏

1、信息的封装和隐藏

2、四种访问权限修饰符

热门文章

最新文章

相关课程

相关电子书

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

训练营

直播

乘风者计划

下载

镜像站

技术资料

【Java基础】——面向对象:封装

一、类和对象

二、类的结构：属性、方法、构造器

1、属性

2、方法

2.1、方法的定义

2.2、方法的重载

2.3、可变个数的形参

2.4、方法参数的值传递机制

3、构造器

3.1、构造器的特征

3.2、构造器的作用：

3.3、构造器重载

三、封装与隐藏

1、信息的封装和隐藏

2、四种访问权限修饰符

热门文章

最新文章

相关课程

相关电子书