大数据JAVA基础第七天

Posted 2020-09-05

1.面向对象编程思想：“类”的引入

前面我们学习过数组，当需要多次遍历数组时，我们可以将遍历的代码封装到方法中，需要遍历时，就调用相应的方法即可，提高代码的复用性。

 

在对数组遍历的基础上继续增加需求，比如获取最值，数组逆转等，同样需要将这些功能封装到相应的方法中。这样继续封装会发现方法越来越多，于是就想能不能将这些方法继续进行封装呢？

 

在前面的学习过程中，我们知道“类”是可以存放方法的（虽然目前还不清楚如何去设计一个完整的类，但最起码知道，类中是可以存放多个方法的），比如：main方法，自定义的add方法，show方法，sop打印方法等。所以，我们就考虑使用“类”来封装多个方法，将来有需要再对数组做相关的操作时，不是直接去找自定义的方法，而是先找到封装了这个方法的类，然后使用这个类中的方法。这就是面向对象思想的编程方式。

 

从面相对象编程的角度考虑，类就是对多个方法的封装，当然，在类中除了方法，还有方法需要用到的一些变量等

 

• 功能的封装==>方法
• 多个方法和相关变量的封装==>类

 

当你在编程过程中，想实现一个功能，不是直接在main方法外边去定义方法，而是想到先去定义一个“类”的时候，你已经具备了面向对象的编程思想。

 

2.面向过程思想概述

之前如果想要完成一个需求，一般的步骤是：首先是搞清楚要做什么，然后再分析怎么做，最后我们再写代码实现

 

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

面向过程的代表语言：C语言

3.面向对象思想概述

当需求单一，或者简单时，我们一步一步去操作没问题，并且效率也挺高。可随着需求的更改，功能的增多，发现需要面对每一个步骤很麻烦了，这时就开始改进，能不能把这些步骤和功能再进行封装，封装时根据不同的功能，进行不同的封装，功能类似的，或者有关联关系的封装在一起，这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想。接下来我们看看面向对象到底是什么？

 

假设有一个任务：写一个功能完整的Java程序，然后把这个程序部署到测试环境中

仔细分析这个任务，发现需要完成这个任务的话，应该有两个动作：

• 写程序
• 部署到测试环境

 

如果按照面向过程的编程思想的话，应该编写两个函数，分别用来实现上面提到的两个功能，然后依次调用这些函数，当这两个函数执行完了之后，整个任务就完成了。

 

如果使用面向对象的思想编程的话，就把功能分解，交给不同的“对象”去完成。

对象：可以暂时理解成具有某些功能的一个综合体

 

例如，上面的任务中，涉及到了两个任务，写代码和部署程序，那么就去找哪个对象具有这样的功能，直接调用它们相应的方法就可以了

 

整个过程如下：

首先考虑谁会写代码，谁会部署程序，然后分别去找他们

找到对象1 --> 写代码 --> 完成

找到对象2 --> 部署程序 --> 完成

--> 整个任务完成

 

比如，有如下三个人，每个人都有自己的功能：使用伪码体现

张三{

   Public void  部署程序(){

        System.out.println("部署java程序");

   }

}

 

李四{

   Public  void 写代码(){

        System.out.println("写java代码")

   }

}

 

小明{

   Public void 玩游戏(){

        System.out.println("玩游戏")

   }

}

第三个人不具有想要使用的功能，所以不会用到

另外还有一个人，负责总指挥，调度每个人执行的先后顺序等

老板{

    Public static void main(String[] args){

        李四.写代码();

       张三.部署程序 ();

       ...

    }

}

 

从以上的概述可以得出这样的结论：

面向过程：强调的是过程，每个过程及实施都要自己一步一步去实施，考虑的事情比较多

面向对象：强调的是对象，需要某些功能的时候，去找具有这样功能的对象，然后由对象去调用功能

4.面向对象思想的特点

• 是一种更符合我们思想习惯的思想
• 可以将复杂的事情简单化，不必考虑执行的每一个细节，只从宏观上把握
• 将我们从执行者变成了指挥者

5.类和对象的含义

• 对象：就是一个具体的事物，它有自己的属性和行为

    比如：一只狗，它有属性：颜色，体重，品种，它有行为：跑，叫，看家等等

    比如：一个手机，它有属性：颜色，价格，品牌等，它有行为：打电话，发短信等

    比如：笔记本电脑，它有属性：品牌，价格，内存大小，它有行为：开机，关机，播放音乐，可以打字等等

• 类：同一种事物的抽象，将它们共同的属性和行为抽象出来，就是类

比如前面说的狗，可以抽象出来一个犬类，手机，可以抽象出一个手机类，在代码中就是用关键字class定义类

 

6.类与对象关系

类：是一组相关的变量和方法的集合，是一个抽象的概念。

对象：是类实例化创建出来的，是“类”这个概念的具体表现形式

 

7.类的定义

//学生类，现实世界中“学生”也是一个抽象概念，它是：所有的学生都有的共同点

//在Java中定义类，就是将这些共同点用class类模拟出来

class Student {

    //姓名

    String name;

    //年龄

    int age;

    //地址

    String address;

   

    //所有学生都有“学习”这样的行为，在类中就是定义学习这样的方法

    public void study() {

       System.out.println("学习");

    }

   

    //吃饭的方法

    public void eat() {

       System.out.println("吃饭");

    }

   

    //睡觉的方法

    public void sleep() {

       System.out.println("睡觉");

    }

}

 

类定义举例：

//手机类

//现实世界中，“手机”是一个抽象概念，

//在Java中模拟手机这个事物的话，就可以定义一个类，这个类拥有手机的属性和行为

class Phone {

    //品牌

    String brand;

    //价格

    int price;

    //颜色

    String color;

   

    //打电话的方法

    public void call(String name) {

       System.out.println("给"+name+"打电话");

    }

    //发短信的方法

    public void sendMessage() {

       System.out.println("发短信");

    }

    //玩游戏的方法

    public void playGame() {

       System.out.println("玩游戏");

    }

}

 

8.实例：自定义手机类，并在测试类中测试其中的变量和方法

 

class Phone {

    //品牌

    String brand;

    //价格

    int price;

    //颜色

    String color;

    //打电话的方法

    public void call(String name) {

       System.out.println("给"+name+"打电话");

    }

   

    //发短信的方法

    public void sendMessage() {

       System.out.println("发短信");

    }

    //玩游戏的方法

    public void playGame() {

       System.out.println("玩游戏");

    }

}

 

class PhoneDemo {

    public static void main(String[] args) {

       //创建手机对象

       //类名 对象名 = new 类名();

       Phone p = new Phone();

       //直接输出成员变量值

       System.out.println(p.brand+"---"+p.price+"---"+p.color);

       //给成员变量赋值

       p.brand = "华为";

       p.price = 100;

       p.color = "灰色";

       //再次输出

       System.out.println(p.brand+"---"+p.price+"---"+p.color);

       //调用方法

       p.call("佟湘玉");

       p.sendMessage();

       p.playGame();

    }

}

 

9.实例变量和局部变量

 

定义：

实例变量：属于类的实例对象，没有static修饰的，目前接触到的成员变量都是实例变量

局部变量：属于方法的变量，只在方法内有效

 

区别：

在类中的位置不同

实例变量 在类中，并且在方法外定义

局部变量 方法内或者方法声明上（形参）定义

在内存中的位置不同

实例变量 堆内存（属于对象）

局部变量 栈内（属于方法）

生命周期不同

实例变量 随着对象的存在而存在，随着对象的消失而消失

局部变量 随着方法的调用而存在，随着方法的调用完毕而消失

初始化值不同

实例变量 有默认的初始化值（0/false/null）

局部变量 没有默认的初始化值，必须先定义，赋值，才能使用。

 

举例：验证局部变量的作用范围和必须初始化才能使用

 

10.

/*

局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。

*/

class Variable {

    //成员变量

    //int num = 10;

    int num; //成员变量有默认值0/false/null

    public void show() {

       //int num2 = 20; //局部变量

       //可能尚未初始化变量num2

       //int num2; //没有默认值，只能先赋值，之后才能使用

       int num2 = 20;

       System.out.println(num2);

       //方法内使用的变量采用就近原则：方法内没有，就去找成员变量

       System.out.println(num);

    }

}

 

class VariableDemo {

    public static void main(String[] args) {

       Varialbe v = new Varialbe();

       System.out.println(v.num); //访问成员变量

       v.show();

    }

}

11.形式参数问题

• 基本类型作为形式参数：传值，实际上就是把实参的值拷贝一份给形参，形参不论怎么改动，都不会影响到实参的值
• 引用类型作为形式参数：传递的是实参所指向的实例对象或者数组，即：传递的是实参的引用（地址值），形参和实参具有相同的引用，所以，形参对引用的改动能立即从实参上看到

/*

    形式参数的问题：

       基本类型：形式参数的改变不影响实际参数

       引用类型：形式参数的改变直接影响实际参数

*/

//形式参数是基本类型

class Demo {

    public int sum(int a,int b) {

       return a + b;

    }

}

 

//形式参数是引用类型

//先自定义一个类，有一个实例方法show

class Student {

    public void show() {

       System.out.println("学习");

    }

}

 

class StudentDemo {

    //如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里需要的是该类的对象。

    public void method(Student s) {

//调用的时候，把main方法中的s的地址传递到了这里 Student s = new Student();

       s.show();

    }

}

 

class ArgsTest {

    public static void main(String[] args) {

       //形式参数是基本类型的调用

       Demo d = new Demo();

       int result = d.sum(10,20);

       System.out.println("result:"+result);

       System.out.println("--------------");

      

       //形式参数是引用类型的调用

       //需求：我要调用StudentDemo类中的method()方法

       StudentDemo sd = new StudentDemo();

       //创建学生对象

       Student s = new Student();

       sd.method(s); //把s的地址给到了这里

    }

}

12.匿名对象

匿名对象：就是没有名字的对象，是对象的一种简化表示形式

 

匿名对象的两种使用情况

• 对象调用方法仅仅一次的时候，多次调用的时候，不适合用匿名对象
• 作为实际参数传递可以使用匿名对象

 

/*

    匿名对象：就是没有名字的对象。

    匿名对象的应用场景：

       A:调用方法，仅仅只调用一次的时候。

           注意：调用多次的时候，不适合。

           这种匿名调用有什么好处吗?

           有，匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。

       B:匿名对象可以作为实际参数传递

*/

class Student {

    public void show() {

       System.out.println("我爱学习");

    }

}

 

class StudentDemo {

    public void method(Student s) {

       s.show();

    }

}

 

class NoNameDemo {

    public static void main(String[] args) {

       //带名字的调用

       Student s = new Student();

       s.show();

       s.show();

       System.out.println("--------------");

       //匿名对象

       //new Student();

       //匿名对象调用方法

       new Student().show();

       new Student().show(); //这里其实是重新创建了一个新的对象

       System.out.println("--------------");

       //匿名对象作为实际参数传递

       StudentDemo sd = new StudentDemo();

       //Student ss = new Student();

       //sd.method(ss); //这里的s是一个实际参数

       //匿名对象

       sd.method(new Student());

       //再来一个，两个都是匿名对象

       new StudentDemo().method(new Student());

    }

}

 

13.封装概述

封装概述

封装是面向对象编程的三个重要特征之一，其余两个是多态和继承。

封装指的是隐藏对象的属性和实现细节，不允许外部直接访问对象的内部信息，而是通过该类提供的方法来实现对内部信息的访问。

封装是对现实世界的模拟，在现实世界中，对象的状态信息都被隐藏在对象的内部，外界无法直接操作和访问，例如一个人的年龄，是逐年增长的，假如暴露给外界的话，有可能会被外界修改。

对一个类或者对象的良好封装，可以达到以下的效果：

好处：

• 隐藏实现细节，
• 让使用者只能通过事先预定的方法来访问数据，从而可以在这个方法内加入逻辑控制，限制对成员变量的不合理访问
• 可以进行数据检查，从而有利于保证对象信息的完整性
• 便于修改，提高代码的可维护性

 

为了实现良好的封装，需要从以下两个方面来考虑

• 把对象的实例变量和实现细节隐藏起来，不允许外界直接访问
• 把方法暴露出来，让方法来控制对这些成员变量进行安全的访问和操作

14.

使用一个关键字private来修饰成员变量，外界就不能对它直接访问了，想要使用它的话，就必须提供公开的方法来对它进行访问，在这个方法中，就可以加入一些逻辑判断了，例如：

/*

    定义一个学生类：

       成员变量：name，age

       成员方法：show()方法

    我们在使用这个案例的过程中，发现了一个问题：

       通过对象去给成员变量赋值，可以赋值一些非法的数据。

       这是不合理的。

       应该是这个样子的：在赋值之前，先对数据进行判断。

       判断到底在哪里做比较合适呢?

       StudentDemo类是一个测试类，测试类一般只创建对象，调用方法。

       所以，这个判断应该定义在Student类中。

       而我们在成员变量的位置可不可以进行数据判断呢?

       是不可以的，因为做数据校验，必须要依靠一些逻辑语句。

       逻辑语句是应该定义在方法中的，所以，我们最终决定在Student类中提供一个方法来对数据进行校验。

    按照我们前面的分析，我们给出了一个方法进行校验。

    但是呢，它偏偏不调用方法来赋值，还是直接赋值了，

    这样我们的方法就没有起到作用。

    我就应该要求你必须使用我的方法，而不能直接调用成员变量赋值。

    怎么去强制要求不能直接使用成员变量呢?

    针对这种情况，Java就提供了一个关键字 private

    private:私有的。可以修饰成员变量和成员方法。

    注意：被private修饰的成员只能在本类中访问。

    其实我讲到现在讲解的是一个封装的思想。

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

*/

class Student {

    //姓名

    String name;

    //年龄

    private int age;

    //写一个方法对数据进行校验

    /*

       返回值类型：void

       参数列表：int a

    */

//age变量是私有的变量，在外界不能直接访问，但是类内部的方法却可以访问

//在外界通过访问这个公共方法，间接的访问到了私有的成员变量

//并且在方法内部还可以加入逻辑判断

    public void setAge(int a) {

       if(a < 0 || age > 150) {

           System.out.println("年龄值非法");

       }else {

           age = a;

       }

    }

    //show()方法,显示所有成员变量值，show()方法是公有的，所以能被外界直接访问

    //由于show()方法是在类中定义的，所以本类中的所有变量都是可以被它访问的

    //这样达到了间接访问的效果

    public void show() {

       System.out.println("姓名："+name);

       System.out.println("年龄："+age);

    }

}

class StudentDemo {

    public static void main(String[] args) {

       //创建学生对象

       Student s = new Student();

       s.show();//默认值

       System.out.println("--------------");

       //给成员变量赋值

       s.name = "林青霞";

       //s.age = 27;

       s.setAge(27);

       s.show();

       System.out.println("--------------");

       //给age赋值

       //s.age = -27; //这个数据是不合理的

       //通过方法给值

       s.setAge(-27);

       s.show();

       System.out.println("--------------");

    }

}

 

一旦将成员变量定义成private的，就不能直接访问了，比如：

Student s = new Student();

System.out.println(s.age);//error

 

15.private关键字

private关键字：

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

 

private最常见的应用：

• 把成员变量用private修饰
• 提供对应的getXxx()/setXxx()方法，这样在类的外部就可以通过公有的方法对这些私有变量进行访问了

一个标准的使用案例

class Demo {

    //int num = 10;

    //用private修饰，只能在类中进行访问

    private int num = 10;

    public void show() {

       System.out.println(num);

    }

//私有方法，只能在类中进行调用

    private void method() {

       System.out.println("method");

    }

    public void function() {

       method();

    }

}

 

class PrivateDemo {

    public static void main(String[] args) {

       Demo d = new Demo();

       //不能访问私有的成员变量

       //System.out.println(d.num);

       d.show();

       //不能访问私有的成员方法

       //d.method();

       d.function();

    }

}