3、JAVA面向对象理解

3. 面向对象

1. 思想概论

1、面向对象与面向过程？

面向过程：强调的是每一个功能的步骤

面向对象：强调的是对象，然后由对象去调用功能   

面向对象是基于面向过程的编程思想。

2、面向对象的思想特点？

A:是一种更符合我们思想习惯的思想

B:可以将复杂的事情简单化

C:将我们从执行者变成了指挥者

3、举例：

买电脑：

      面向过程：我的了解电脑--了解我自己的需求--找对应的参数信息--去中关村买电脑--讨价还价--买回电脑

      面向对象：我知道我要买电脑 -- 班长去给我买 -- 班长就买回来了

洗衣服：

      面向过程：把衣服脱下--找一个盆--放点洗衣粉--加点水--把衣服扔进去--搓一搓--清洗衣服--拧干--晾起来

      面向对象：把衣服脱下--打开全自动洗衣机--扔进去--一键即可--晾起来

吃饭：

      面向过程：去超市买菜--摘菜--洗菜--切菜--炒菜--盛起来--吃

      面向对象：上饭店吃饭，你--服务员(点菜)--厨师(做菜)--服务员(端菜)--吃

      家常事物，买洗衣机和去饭店太不划算了，所以，找个对象。

      但是，你不跟我好好学习，你将来4000，你对象8000。                

4:把大象装进冰箱

面向过程：

动作有哪些呢?

      A:打开冰箱门  B:装进大象      C:关闭冰箱门 

代码体现

class Demo {

           public static void main(String[] args) {

                 /*

                 System.out.println("打开冰箱门");

                 打开冰箱门的东西，我现在仅仅是为了演示，就写了一个输出语句,其实，它可能需要做很多操作。

                 这个时候代码就比较多一些了,假设我要多次打开冰箱门，代码一多，每次都写一遍，麻烦不

                 我们就应该用方法改进

                 System.out.println("装进大象");

                 System.out.println("关闭冰箱门");

                 */

                 //写了方法以后，调用就改变了

                 open();

                 in();

                 close();

                 }               

           public static void open() {

                      System.out.println("打开冰箱门");

                 }

                      public static void in() {

                            System.out.println("装进大象");

                      }

                      public static void close() {

                            System.out.println("关闭冰箱门");

                      }

                 }

 

5、面向对象：

我们怎么才能更符合面向对象思想呢?

      A:有哪些类呢? B:每个类有哪些东西呢?    C:类与类直接的关系是什么呢?

把大象装进冰箱的分析? (如何分析有哪些类呢?UML。名词提取法。)

      A:有哪些类呢? 大象    冰箱    Demo

      B:每个类有哪些东西呢?大象：进去    冰箱：开门关门    Demo:main方法

      C:类与类直接的关系是什么呢?Demo中使用大象和冰箱类的功能。

代码体现：

class 大象 {

           public static void in() {

                 System.out.println("装进大象");

           }

      }

class 冰箱 {

           public static void open() {

                 System.out.println("打开冰箱门");

           }                    

           public static void close() {

                 System.out.println("关闭冰箱门");

                 }

           }

class Demo {

           public static void main(String[] args) {

                 冰箱调用开门

                 大象调用进去

                 冰箱调用关门

           }

      }

 

6、开发，设计，特征

面向对象开发

      就是不断的创建对象，使用对象，指挥对象做事情。     

面向对象设计

      其实就是在管理和维护对象之间的关系。

面向对象特征

      封装(encapsulation)

      继承(inheritance)

         多态(polymorphism)

2. 类与对象

现实世界中是如何描述一个事物的呢?

   举例：学生

        姓名,年龄,性别... 学习,吃饭,睡觉     

   属性：该事物的描述信息   行为：该事物能够做什么

我们学习编程语言，是为了模拟现实世界的事物的。而我们学习的编程语言Java中最基本的单位是：类。所以，我们就应该把事物通过类来体现出来：由此，我们就得到了现实世界事物和类的对应关系：

事物：                 类： 

   属性                成员变量

   行为                成员方法

类：是一组相关的属性和行为的集合。是一个抽象的概念。

对象：是该类事物的具体表现形式。具体存在的个体。

举例：

   学生：类  班长：对象

4. 总结1

2:两个思考题(理解)

   (1)Java中的参数传递问题

      Java中只有值传递。

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

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

3:面向对象(掌握)

   (1)面向对象

      面向对象是基于面向过程的编程思想

   (2)面向对象的思想特点

      A:是一种更符合我们思考习惯的思想

      B:把复杂的事情简单化

      C:让我们从执行者变成了指挥者

      举例：

        买电脑

        洗衣服

        做饭

        ...

        万事万物皆对象

   (3)把大象装进冰箱(理解)

      A:面向过程实现

         B:面向对象实现

      注意：如何让我们的操作更符合面向对象思想呢?

      A:有哪些类

      B:每个类有哪些成员

      C:类与类的关系

   (4)类与对象

      A:现实世界的事物

        属性  事物的基本描述

        行为  事物的功能

      B:Java语言中最基本的单位是类。所以，我们要用类来体现事物

      C:类

        成员变量 事物属性

        成员方法 事物行为

      D:类：是一组相关的属性和行为的集合。是一个抽象的概念。

        对象：是该类事物的具体存在，是一个具体的实例。(对象)

        举例：

        学生：类

        班长：对象

   (5)类的定义及使用

      A:类的定义

        成员变量 定义格式和以前一样，就是位置不同，在类中，方法外。

        成员方法 定义格式和以前一样，就是去掉了static。

      B:使用类的内容

        a:创建对象? 格式

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

        b:如何使用成员变量和成员方法呢

           对象名.成员变量

           对象名.成员方法()

   (6)Java程序的开发，设计和特征

      A:开发：就是不断的创建对象，通过对象调用功能

      B:设计：就是管理和维护对象间的关系

      C:特征

        a:封装

        b:继承

        c:多态

5. 成员\局部变量的区别

/*

   成员变量和局部变量的区别?

      A:在类中的位置不同

        成员变量：在类中方法外

        局部变量：在方法定义中或者方法声明上

      B:在内存中的位置不同

        成员变量：在堆内存

        局部变量：在栈内存

      C:生命周期不同

        成员变量：随着对象的创建而存在，随着对象的消失而消失

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

      D:初始化值不同

        成员变量：有默认初始化值

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

       

      注意事项：

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

*/

class Varialbe {

   //成员变量

   //int num = 10;

   int num; //0

  

   public void show() {

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

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

      //int num2; //没有默认值

      int num2 = 20;

      System.out.println(num2);

     

      //int num = 100;

      System.out.println(num);

   }

}

class VariableDemo {

   public static void main(String[] args) {

      Varialbe v = new Varialbe();

     

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

     

      v.show(); 

       

   }

}

 

6. 形式参数的问题

/*

   形式参数的问题：

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

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

*/

//形式参数是基本类型

class Demo {

   public int sum(int a,int b) {

      return a + b;

   }

}


//形式参数是引用类型

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的地址给到了这里

   }

}

7. 匿名对象

/*

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

   匿名对象的应用场景：

      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());

   }

}

8. 封装&private关键字

/*

   定义一个学生类：

      成员变量：name，age

      成员方法：show()方法

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

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

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

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

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

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

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

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

      逻辑语句是应该定义在方法中的，所以，我们最终决定在Student类中提供一个方法

      来对数据进行校验。

  

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

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

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

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

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

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

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

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

     

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

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

*/

class Student {

   //姓名

   String name;

   //年龄

   private int age;

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

   /*

      返回值类型：void

      参数列表：int a

   */

   public void setAge(int a) {

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

        System.out.println("你给的年龄有问题");

      }else {

        age = a;

      }

   } 

   //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("--------------");

   }

}