面向对象基础

6.1.1 面向对象的基本概念

1）面向对象的基本思想： 把问题看成是若干个对象组成，这些对象之间是相互独立的，但又可以相互配合、连接和协调，从而共同完成整个 程序要实现的任务和功能；

面向对象的三大特征：封装 、 继承 、多态；

2）对象的定义：描述客观事物的一个实体

3）类：几个对象之间具有的一些共同 的特征，把这些 共同的特征和共同的行为组织到一个单元中，就得到了类；

类是具有相同属性和方法的一组对象的集合；类定义了对象将会拥有的特征和行为。

    类   <--> 对象  关系：  模具和用这个模具制作出的物品之间的关系。一个类给出它的全部对象的一个统一的定义，而他的每个对象则是符合这种定义的一个实体。 类和对象的关系就是抽象和具体的关系，类是多个对象进行综合抽象的结果，是实体对象的概念模型， 而对象是一个类的实例；

6.1.2 定义类

面向对象设计 的过程-----抽象的过程：

（1）发现类，类定义了对象将会拥有的特征（属性）和行为（行为）

（2）发现类的属性，对象所拥有的静态特征在类中表示时称为类的属性；

（3）发现类的方法，对象执行的操作称为类的方法；

1.定义类：

[访问修饰符] class 类名{

// 省略类的内部具体代码

}

2. 属性   ------对象所拥有的特征在类中表示时称为类的属性；

[访问修饰符] 数据类型 属性名；

3.方法    ------对象执行操作的行为称为类的方法

[访问修饰符] 返回类型 方法名称（ 参数类型  参数名1 ， 参数类型 参数名2, ......）{

       //........省略方法体代码

}

返回类型可以是void ， 在定义方法是，void表示没有返回值，方法体中不必使用"return"关键字返回具体数据，但是可以使用 “return”关键字退出方法；

返回类型如果不是void ， 方法体一定使用“return” 关键字返回对应类型的结果，否则程序就会编译错误；

6.1.3 创建和使用对象

1.创建对象

类的对象可以调用类中的成员，如属性和方法；

语法：

类名 对象名 = new 类名（）；

-----new是关键字

-----左边类名是对象的数据类型

-----右边的类名（）称为类的构造方法

2.使用对象      ------- 引用对象的属性和方法，需要使用“ . ”

对象名 . 属性          //引用对象的属性

对象名 . 方法名()           // 引用对象的方法

public class hh {
    public static class Person{
        public String name;
        public String gender;
        public int age;
        public void work(){
            System.out.println(this.name+"的工作理念：干活挣钱有饭吃");
        }
    }
    public static void main(String[] args) {
        Person hanbing = new Person();
        hanbing.name = "韩冰";
        hanbing.gender = "女";
        hanbing.age = 22;
        hanbing.work();
    }
}

面向对象的优点：

1.与人类思维习惯一致，从人类考虑问题的角度出发，将人类思维模式转换成程序能够理解的过程。面向对象程序设计使用“类”来模拟现实世界的抽象概念，用“对象” 来模拟现实世界中的实体，用计算机解决问题；

2.信息隐藏，提高程序的安全性和可维护性：封装实现模块化和信息隐藏

（1）将类的属性和行为封装在类中，保证修改不会影响到其他对象，方便维护；

（2）封装使得在对象外部不能随意访问对象的属性和方法，避免外部错误对他的影响，提高安全性；

3.提高程序可用性 

一个类可以创建多个对象实例，体现了重用性；

3. 对象数组

public class Person {
    public int age;      //年龄
    public String name;    //姓名
    public Person(int age , String name){   //两个参数的构造方法
        this.age  = age;
        this.name = name;
    }
    public static class Test{
        public static void main(String[] args) {
            Person[] person = {new Person(22,"韩冰") , new Person(23,"刘敦" ), new Person(24, "马达") };
            for(int i = 0; i < person.length ; i++){
                System.out.println("age属性等于"+person[i].age + ", " +"name 属性等于"+person[i].name);
            }
        }
    }
}

 

6.2.1 成员方法

类成员：成员方法 & 成员变量

方法重载 ----- 在一个类中定义多个同名的方法，但要求每个方法具有不同的参数类型和参数个数；

public class P {
    public String name;    //姓名
    public String gender;  //性别
    public int age;        //年龄
    //无参数的工作方法
    public void work(){
        System.out.println(this.name+"的工作理念：干活挣钱有饭吃");
    }
    //带参数的工作方法
    public void work2(String content){
        System.out.println(this.name+"的工作理念：干活挣钱有饭吃");
    }

    
}

方法重载的特点：

-----在同一个类中

-----方法名相同

-----参数的个数或类型不同

-----方法的返回值不能作为判断方法之间是否构成重载的依据

调用工作的方法：

work() 方法形成方法重载， hanbing对象后面使用“.” ，出现所示信息， 提示有两个work（）方法可以选择，使用上下键并单击，选择所要使用的方法；

方法重载的优点：

对原方法的一种升级，根据参数的不同，采用不同的实现方法，不需要编写多个名称，简化了类调用方法的代码；

6.2.2 成员变量

1）成员变量作用域

类中的属性，也就是直接在类中定义的变量称作成员变量，定义在方法的外部；

Person类中的name / gender 既不属于eat（）方法， 也不属于work（）方法， 而属于Person 类本身的属性，他们是Person类的成员变量；

public class Person {
    public int age;      //年龄
    public String name;    //姓名
    public String gender;   //性别
    public Person(int age , String name){   //两个参数的构造方法
        this.age  = age;
        this.name = name;
    }
    public void eat(String name){
        System.out.println(this.name + "邀请" + name + "共进晚餐");
    }
    public void work(){
        int age = 18;
        System.out.println(this.name + age + "岁的工作理念：干活挣钱有饭吃");
    }
    public  void work(String content){
        System.out.println(this.name + " 的工作理念"+content);
    }
    public void showDetails(){
        System.out.println("姓名是："+this.name + ", 性别为：" +this.gender+ ", 年龄是："+ this.age);
    }

    public static class Test{
        public static void main(String[] args) {
            Person[] person = {new Person(22,"韩冰") , new Person(23,"刘敦" ), new Person(24, "马达") };
            for(int i = 0; i < person.length ; i++){
                System.out.println("age属性等于"+person[i].age + ", " +"name 属性等于"+person[i].name);
            }
        }
    }
}

2）局部变量和成员变量的区别

1.作用域不同

-----局部变量作用域仅限定义他的方法，在该方法外无法访问他。

-----成员变量的作用域在整个类内部都是可见的，所以成员方法都可以使用他，如果访问权限允许，还可以在类外面使用成员变量。

2.初始值不同

-----成员变量如果在类定义中没有赋予它初始值，java会给他一个默认值，基本数据类型=0，引用数据类型null

-----局部变量不会被赋予初始值， 局部变量必须定义并赋值后再使用

3.

-----局部变量，在同一个方法中，不可以同名

-----局部变量，在不同方法中，可以同名

4.

-----局部变量可以和成员变量同名， 并且在使用中，局部变量拥有更高的优先级；

3）数据类型

引用数据类型：类、数组、接口

int 和 class 在内存中的存储方式不同， 这是基本数据类型和引用数据类型的主要区别；

-----对于基本数据类型： 不同的变量会分配不同的存储空间，并且存储空间中存储的是该变量的值。 赋值操作传递的是变量的值， 改变一个变量的值不会影响另一个变量的值；

-----对于引用数据类型：赋值是把原对象的引用（可以理解为内存地址） 传递给另一个引用； 对数组而言， 当一个数组名直接给另一个数组名赋值时， 相当于传递了一个引用； 两个引用指向同一个数组，也就是指向同一个内存空间；

（传递参数是也有以上差别);

6.2.3 构造方法

java中， 类创建一个对象时会自动调用该类的构造方法， 构造方法分为默认构造方法和带参数的构造方法；

定义

-----构造方法的主要作用是进行一些数据的初始化；

[访问修饰符] 方法名（[参数列表]）{

       //.......省略方法体的代码

}

-------构造方法没有返回值

-------默认构造方法没有参数， 因此参数列表可选

-------构造方法的方法名与类名相同

（当开发人员没有编写自定义构造方法时， java会自动添加默认构造方法， 默认构造方法没有参数）

 

封装

定义：

1）将类的状态信息隐藏在类的内部， 不允许外部程序直接访问 ， 通过对该类提高的方法实现对隐藏信息的操作和访问；

2）反应事物的相对独立性， 避免外部错误对当前对象造成影响；

3）对象之间实现 松耦合 (减少对象之间关联性， 降低复杂度和依赖性）关系，隐藏类的实现细节， 使用者通过特定方法访问数据， 更方便加入存取控制符

封装的步骤

修改属性的可见性    --->     私有变量设置setter() 与 getter() 方法    --->  设置属性的存取限制

 

包

定义： package    声明在第一条注释 例： package src    

1）包允许将类组合成较小的单元（类似文件夹） ， 易于找到使用相应的类文件；

2）避免命名冲突 ， java只有在不同的包中类才能重名

3）包允许在更广的范围内保护类、 数据 和方法， 根据访问规则， 包外的代码有可能不能访问该类；

包的使用

声明包的含义是声明当前类所在的包

package cn.xxx.pack1

导入包的含义是声明在当前类中使用到的其他类所在的包

package cn.xxx.pack2

import cn.xxx.pack1.类名

 

访问修饰符

 

类和类成员的访问控制

修饰符\作用域	在同一个包中	非同一包
public	可	可
默认修饰符	可	不可

 

类成员的访问修饰符(Y yes   N no)

修饰符\作用域	同一类中	同一包中	子类中	其他地方
private	Y	N	N	N
默认修饰符	Y	Y	N	N
protected	Y	Y	Y	N
public	Y	Y	Y	Y

 

static 关键字

static 修饰的属性是 静态变量 （类属性）

static 修饰的方法 静态方法（类方法）