Java ------ 面向对象程序设计

面向对象

        什么是面向对象？

       场景1： 一个人在抽烟

　　面向对象：面向对象是一种耦合度低、扩展性强的编程思维方式，以 场景1 为例：张三在一个树下抽烟；

       从这个场景中可以提取 对象 ： 张三 、 烟、树、打火机；可以发现这几个其实在这个场景中没有谁是不可被替代的，每一样如果把它拿下来，在换个新的，构成的场景其实大致相同的；比如说：将树换下来，把河边换上去，打火机可以把普通的换成名牌的...... 

       所以面向对象的思维方式更贴近人类的理解。

       面向过程：面向过程是一种耦合度很高的编程方式

1、类的定义 

       类的定义也可以称为类的声明，具体的是由数据成员变量和成员方法组成；

格式：

        修饰符 class 类名 [extends 父类名] {

               修饰符 类型 成员变量；

         .....

               修饰符 类型 成员方法（参数列表）{

                               方法体

                } 

         } 

         类的格式与组成的成员都已弄清楚了，但又出现了新的问题 ------ 为什么要构成类，类的作用是什么？

                 将一个现实问题通过代码程序进行实现，要有太多太多的代码需要去编写，在编写程序的过程中，不能想当然的想到哪就写到哪，需要对现实产生的问题一步步的剖析，寻找其中的相似点，连贯点，并且将各个相似的问题结合在一起，通过一个或较少的代码块去执行这些相似问题的答案，使得在人类的理解层面上可以简单，易懂；在计算机的运行层面上可以减少内存的消耗，提高执行的速度；

 1 /**
 2  *  类的定义
 3  */
 4 public class Test22 extends Object{  // 这就是一个类 需要 class 关键字才能创造一个类
 5   // extends 也是一个关键字 ，可以通过它对父类进行继承
 6 
 7     // 类中有 成员变量 与 成员方法
 8 
 9     public int  i = 0;  // 成员变量
10 
11     public static void m3() {  // 成员方法（静态）
12         int i = 0;  // 局部变量
13     }
14 }

        类太重要了，重要到如果要以面向对象的方式去编程，那么就永远也少不了类的存在，所以不单单只是了解类的定义，类的作用，还需要考虑类在底层是如何运行的，类与类之间又是什么关系；

        创建对象与使用的内存分析：

        创建对象与使用都离不开类，只有有类的存在才可以创建对象，所以可以将类看成面向对象的基本单元，而所有的 java 程序运行都需在 JVM 中运行，并且 JVM 虚拟机给程序员设立了三个区块，分别是：方法区、堆区、栈区；而一个类在创建对象的过程中，对象在 JVM 运行时是在哪些区块中工作呢？怎么工作呢？

 1 public class Test15 {  // 定义了一个类
 2 
 3     public static void main(String[] args) {
 4         
 5         // 如何去创建一个对象：
 6          // 使用 new 基本运算符  以： new Ren（类名）() 的格式来创建
 7         Ren r = new Ren();  
 8         // 创建好了一个对象，那么创建这个对象的作用是什么？
 9         // 在另一个类中创建一个对象的目的是对创建好的对象进行调用其属性
10              
11         // 调用的方式是： 引用.变量名  ；  其中该对象中的 r 就是一个引用 也是一个局部变量 也是一个实例变量    
12         // String s = r.name = "程俭"; // 这样的书写格式不被允许 要进行分段赋值
13         String s = r.name;  // 调用 Ren 中的属性
14         s = "程俭";
15         // 可以对对象中的属性进行赋值
16          
17         System.out.println(s);
18         r.m2(); // 调用 Ren 中的方法
19         
20         // 可以对同一个类进行多次对象的创建，但每个对象都不相等
21         Ren b = new Ren();  
22         
23         int i = b.age;
24         System.out.println(i);
25     }
26 }
27 /**总结： 一个类的可以被另一个类调用，但是调用的前提是先创建被调用类的对象，
28  *       完成后可以通过引用的方式去调用被调用中的属性与方法，并且在调用的过
29  *       程中可以对属性进行赋值；
30  * */
31 
32 
33 class Ren{    // 定义了一个类
34     
35     // 属性
36     String  name;
37     
38     int age;
39     
40     public void m2() {
41         System.out.println("大家好！！");
42     }
43 }

      在创建对象中类与类之间、对象与对象之间又是一个什么样的关系呢？

 1 public class Test16 {
 2 
 3     public static void main(String[] args) {
 4         
 5         Car c = new Car();
 6         Master m = new Master();
 7         
 8       // c.name.name = "程俭";
 9       // System.out.println(c.name.name);
10         /*Exception in thread "main" java.lang.NullPointerException
11           at If/Review.Test16.main(Test16.java:10)
12         
13           出现了空指针异常，那么原因是什么？
14               看 11 行，语法上没有错误，通过 Car 的引用去调用  Master 的实例化变量，然后通过 Master 的实例化变量去调用 Master 中的属性
15                    从上面这句话可以看到完全一点毛病都没有，而且也能看到 Car 与 Master 是相关联的，但是偏偏出现空指针异常了
16                    原因其实还是如字面意思----空指针异常一样，两者在语法和编写的过程中是有相关联，但是在 JVM 虚拟机，Car 与 Master 两者的内
17                    存地址根本没有相关联，所以出现了空指针异常        
18         */
19         
20         c.name = m;  
21         c.name.name = "程俭";
22         System.out.println(c.name.name);
23         
24         // 要想两个对象（两个类）相关联，那么它们必须其内存地址相关联，其中一个对象的实例化变量 要指向另一个对象的引用，才可以通过该被调用对象的引用来调用其属性
25         
26     }
27 }
28 
29 class Car{
30     
31     String brand;
32     int number;
33     
34     // 引用数据类型
35     Master name;
36 }
37 
38 class Master{
39     
40     String name;
41 
42     // 基本数据类型
43     int age;
44     
45     int id；    
46 }

2、对象的封装性

       封装性：就是将一些用户不必要知道的底层代码进行包装，可以使用户能方便使用，对于程序员来说，可以保证了底层的代码安全性和稳定性  -----化繁为简

       private 关键字  -------> 私有化:

public class Pri{
        
        private String name;   

}                        

　  该类中的属性被私有化后，其他类在对其创建对象调用时，只能调用，无法修改或赋值，要想对该值赋值，只能回原类进行赋值修改；

      可是这样做虽然保证了稳定性与安全性，但是对程序员来说却形成了一种障碍，如何再改进既能保证封装性与安全性，又能便捷的可修改赋值封装后的属性呢？

      对于这样的设定 其实有了解决的办法：set （写）--------- 不返回值 ； get （读）---------- 返回类型值；

 1 public class Test17 {
 2 
 3     public static void main(String[] args) {
 4         
 5         Numeric m = new Numeric();
 6         
 7         m.setNumber(-10);
 8         
 9         System.out.println(m.getNumber());
10     }
11 
12 }
13 
14 
15 class Numeric{
16     
17     private int number;
18 
19      
20     public void setNumber(int number) {   // 使用get 与 set 时要记住 变量名首字母要大写
21 
22     if (number < 0 || number > 1000) {
23             System.out.println("对不起该数不合法无法使用");        
24             return;
25         }
26         
27       this.number = number;
28     }
29     
30     public int getNumber() {
31         return number;
32     }
33 }