Java学习笔记--关于面向对象的思考

1.不可改变的类生成对象以及变量的范围

2. 关键词this的使用

3.用类抽象的思想制作软件

4.通过关系模型建立类

5.使用面向对象的范例来设计程序，遵循类设计指导。

已经学习了：怎么定义类已经创建对象，还有就是通过Java API 来使用类。

1.不可变的类和对象

　　正常来说，我们使用类的时候都是为了生成一个对象，允许在以后更改对象的内容，但是有时候会要求不能改变他的内容。比如我们记录学生档案的时候，又或者是个人简历的时候，有些档案比如出生日期，一旦是确定的不会去更改，但是学历，工作经验会随着个人的成长而改变。Java中也有一些类是不会变的，前面提到String类，里面的内容一般是会变的，改变的时候参考这个值的String 变量所指向的字符串。只需要将数据区私有，然后在公共的方法上不能够更改这些信息，就实现了我们的目标。在类里面数据区的变量只能声明一次，但是在方法中的不同程序块变量可以声明很多次。

　　例子

public class circle{
 private int x = 0;
 private int y = 0;
 public circle(){

}   
 public void p(){
    int x = 1;
    system.out.println("x = " +x);
    system.out.println("y = " +y);  
} 
}

此时对比x和y的输出的值，可以发现在p方法中的x的值已经改变，但是y的值没有改变，也就是后来在方法中 定义的x ，他的作用域就在方法p中。为了避免混淆犯错，不要在方法里面使用本地变量或者是静态变量，除了是用方法来传递参数的位置。

2. 关键词this的使用

　　关键词this的使用，this是一个参考的名称，它指向的是唤醒这个对象的它本身，最直接的就是用来参考类本身的隐藏数据区。

　　

public class Circle{
  int x = 10;
  static double k = 11;
   void setX(int x){
      this.x = x;  
 }
   static void setK(double k){
      Circle.k= k;
   }
}

　　通过关键词this可以得到对象，然后唤起实例，this.x = x就是要让参数的x赋值到唤起的对象的数据区，如果说将this的用法改成 this(abc)，也就可以理解为这个类的构造方法。

3.用类抽象的思想制作软件

     类的抽象和封装。类的抽象就是使用类，并且实现类之中的一部分内容，创建这个类必须要让用户知道它是如何使用的，方法和数据可以从外部和类中的到。类的实现的思想，对于客户机而言，类就像一个黑盒，使用的时候将这些抽象出来，然后得到方法和内容的签名。客户端通过抽象类来使用。生活中将电脑细分为很多部分，CPU，内存，硬盘，主板。每个部分都是一个对象，每个部分都有属性和方法，为了整合起一整台计算机，我们必须要知道每个部分是怎么使用的，以及它们之间是如何交互，内部的东西已经封装起来了，我们不必去了解每个触发器，锁存器是怎么工作的，只需了解整体的模块功能。

　　也就是说 1 开发类和使用类是两种独立的任务

　　　　　　　2 可以跳过复杂的类来，然后学习整个工程

　　　　　　　　3 通过使用类可以更好地知道怎么来实现

　　面向对象的思想：

　　    public static double gerBMI(double weight, double height)

     这个方法，可以计算我们身体的BMI值，然后还是很有限，因为的到这些信息以后，我们日常使用时，作为某个人身体情况的衡量指标，这些信息就要和这个人的其他信息连接起来，此时可以按照以下的例子创建类：

　　

String name;
int age;
double weight;
double height;
BMI(name: String , age: int ,weight:double, height: double)
getBMI       

   对象也可以包含另外一个对象，就像上面一个BMI的例子中写的一样，在BMI中就有关于String类生成的字符串，类之间的关系也有很多种，比如以下三个类

　　学生类，姓名类，家庭地址类。一个学生对应一个名字，但是可能会有两个学生的地址是一样的，这个地址由这两个学生共享，也就是通过关系的模型来建立类。

public class Name{
    ...
}
public class Student{
   private Name name;   
   private Address address;  
}
public class Address{
  ...   
}

4.通过关系模型建立类

　　例子：设计一个课程Course 类

　　数据区： courseName: String、 students[]: String 、 numberOfStudent: int

　　方法区： 构造方法Course(courseName: String) ,getCourseName():String, addStudent(student:String): void, dropStudent(student: String):void、 getStudents():String[] ,getNumberOfStudents(): int 

     在这个Course类中可以看到数据结构的影子，一组数据，以及在这组数据上的关系的集合，有点像线性表。

　　Student.java

　　

public class student {
    private String Name;
    public student(String na){
        this.Name = na;
    }
    public String getName()
    {
        return Name;
    }
}

　　Course.java

public class Course {
    private String CourseName;
    private student[] stu;
    private int numberOfStudent;
    
    public Course(String courseNa){
        CourseName = courseNa;
        numberOfStudent = 0;
        stu= new student[20];
    }
    
    public String getCourseName(){
        return CourseName;
    }
    public void addStudent(student s){
        int i = numberOfStudent;
        i++;
        stu[i] = s;    
        numberOfStudent++;
    }
    public void DropStudent(student s){
        numberOfStudent --;
    }
    public String GetStudent(int i){
        return stu[i].getName();
    }
    public int  getNumberOfStudent(){
        return numberOfStudent;
    }
}

main.java

public class Main {
    public static void main(String[] args){
        
        Course cou = new Course("math");
        student stu1 = new student("xiao ming");
        student stu2 = new student("Da ming");
        cou.addStudent(stu1);
        cou.addStudent(stu2);
        System.out.println("The Course Name is "+ cou.getCourseName());
        System.out.println("The number of student is "+ cou.getNumberOfStudent());
        System.out.println("The List :
"+cou.GetStudent(1));
        System.out.println(cou.GetStudent(2));
    }
    
}

5.使用面向对象的范例来设计程序，遵循类设计指导。

　　一个对象应该是描述单一整体，类的操作应该在逻辑上有连贯性的目的。例如你可你将学生加入一个班级，但是不要将员工和学生都加到同一个班级里去，之前学习的String，StringBuilder，StringBuffer，都是用来解决字符串的问题，String用来处理不变的字符串，StringBuilder用来创建可变的字符串，StringBuffer可StringBuilder相似，但是可以StringBuffer包含了synchronized的方法用来更新字符串。

　　高内聚低耦合，前后一致连贯。

摘自百科：

　　耦合性：也称块间联系。指软件系统结构中各模块间相互联系紧密程度的一种度量。模块之间联系越紧密，其耦合性就越强，模块的独立性则越差。模块间耦合高低取决于模块间接口的复杂性、调用的方式及传递的信息

      内聚性：又称块内联系。指模块的功能强度的度量，即一个模块内部各个元素彼此结合的紧密程度的度量。若一个模块内各元素（语名之间、程序段之间）联系的越紧密，则它的内聚性就越高。

      所谓高内聚是指一个软件模块是由相关性很强的代码组成，只负责一项任务，也就是常说的单一责任原则。

      耦合：一个软件结构内不同模块之间互连程度的度量。

      对于低耦合，粗浅的理解是：一个完整的系统，模块与模块之间，尽可能的使其独立存在。也就是说，让每个模块，尽可能的独立完成某个特定的子功能。模块与   模块之间的接口，尽量的少而简单。如果某两个模块间的关系比较复杂的话，最好首先考虑进一步的模块划分。这样有利于修改和组合。