Java面向对象

---

1.面向对象的思想

在Java中我们要完成一个需求，一件事情，首先需要清楚我们要做什么，接着分析怎么做，最后代码实现。一步步去实现，而具体的每一步都需要我们去实现和操作。这些步骤相互调用和协作，完成我们的需求。上面的每一个具体步骤中我们都是参与者，并且需要面对具体的每一个步骤和过程，这就是面向过程最直接的体现。

那么什么又是面向过程呢？

面向过程也就是面向着具体的每个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。例如面向过程的语言有：C语言。

面向对象思想的特点

1. 符合我们的思想习惯

2. 可以将复杂的事情简单化

3. 将我们从执行者变成了指挥者，角色发生了转变

2.面向对象特征

1. 封装 encapsulation

   封装就是把一个对象的状态信息（属性）隐藏在对象内部，外部不允许直接访问和修改，但是可以通过特定的访问和操作方法来操作属性。这样无非是保护了数据的合法性和完整性。例如我们把一个学生的信息封装在一个类中，将所有的属性都进行私有化，这样外部就只能通过我们提供的访问器来访问对象中的属性。

   public class Student {
       private int id;//id属性私有化
       private String name;//name属性私有化
   
       //获取id的方法
       public int getId() {
           return id;
       }
   
       //设置id的方法
       public void setId(int id) {
           this.id = id;
       }
   
       //获取name的方法
       public String getName() {
           return name;
       }
   
       //设置name的方法
       public void setName(String name) {
           this.name = name;
       }
   }

2. 继承 inheritance

   不同类型的对象，相互之间经常有一定数量的共同点。例如，小明同学、小红同学、小李同学，都共享学生的特性（班级、学号等）。同时，每一个对象还定义了额外的特性使得他们与众不同。例如小明的数学比较好，小红的性格惹人喜爱；小李的力气比较大。继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。通过使用继承，可以快速地创建新的类，可以提高代码的重用，程序的可维护性，节省大量创建新类的时间 ，提高我们的开发效率。关于继承有如下三个特点
   1. 子类拥有父类的所有属性和方法（其中包括父类的私有属性和私有方法），但是父类的私有属性和方法子类是无法访问的。
   2. 子类可以拥有自己的属性和方法，也就是说子类可以在父类的基础上进行拓展。
   3. 子类可以用自己的方式去实现父类的方法。

3. 多态 polymorphism

        多态即一个对象具有多种不同的状态，在Java中具体表现为父类的引用指向子类的实例。

        特点：

1. 对象类型和引用类型之间具有继承（类）/实现（接口）的关系；
2. 引用类型变量发出的方法调用的到底是哪个类中的方法，必须在程序运行期间才能确定；
3. 多态不能调用“只在子类存在但在父类不存在”的方法；
4. 如果子类重写了父类的方法，真正执行的是子类覆盖的方法，如果子类没有覆盖父类的方法，执行的是父类的方法。

3.类与对象的概述

类

类是一组相关的属性和行为的集合，定义类其实就是定义成员变量和成员方法。

成员变量：在类中，在方法外

成员方法：去掉static，类似于以前定义方法

对象

对象是该类事物的具体体现。

例如：学生就是一个类，班长是一个对象。

4.简单类的定义

1. 定义一个学生类，属性: 姓名 , 年龄 , 地址 ...；行为: 吃饭 , 睡觉 , 上课 ...。

 public class Student {
     String name;
     int age;
     String address;
     public void eat(){
         System.out.println("吃饭");
     }
     public void sleep(){
         System.out.println("睡觉");
     }
     public void haveClass(){
         System.out.println("上课");
     }
 }

1. 2.编写测试类，在测试类中创建对象使用学生类

   创建对象的方法：

   格式：类名 对象名 = new 类名();

 public class Test {
     public static void main(String[] args) {
         Student student=new Student();
         student.address="local";
         student.age=20;
         student.name="张三";
         System.out.println(student.name);
         System.out.println(student.age);
         System.out.println(student.address);
         student.eat();
         student.haveClass();
         student.sleep();
     }
 }

该测试类的运行结果是:

5.成员变量和局部变量

1. 成员变量

   定义在类内，方法外，在堆内存，随着对象的创建而创建，随着对象的消失而消失，有默认的初始化值

2. 局部变量

   在方法定义中或者方法声明上（形参）的；在栈内存；随着方法的调用而存在，随着方法的调用完毕而消失；没有默认初始化值，必须定义，赋值，然后才能使用。

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

6.匿名对象

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

应用场景：a.调用方法仅仅只调用一次的时候；b.匿名对象可以作为实际参数传递

7.封装

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

2. 封装的好处

   隐藏实现细节，提供公共的访问方式

   提高了代码的复用性

   提高了安全性

3. 封装的原则

   将不需要对外提供的内容都隐藏起来。把属性隐藏，提供公共方法对其访问。

4. private关键字

   private关键字的特点：它是一个权限修饰符，可以修饰成员变量和成员方法，被其修饰的成员只能在本类中被访问。

   例如下面这段代码中定义了一个学生类，但是在name和age成员变量前加了private修饰符，所以在测试类Test中就不能直接访问这些成员变量。

    public class Student {
        private String name;
        private int age;
        String address;
        public void eat(){
            System.out.println("吃饭");
        }
        public void sleep(){
            System.out.println("睡觉");
        }
        public void haveClass(){
            System.out.println("上课");
        }
    }

   在测试类Test中就会出现错误如下：

1. private的应用

   那么在Java中为什么还需要这个权限修饰符呢。假设我们创建了一个类来修改成员变量的值时，就不能判断修改的值是否合理，但是我们添加了private修饰符，那么对象就不能直接修改成员变量，但是我么可以在类中提供方法getXX()和setXX()来帮助对象修改成员变量的值，这样我们可以在这两种方法中定义一些限制的条件，来提高我们程序的鲁棒性。

   例如修改后的Student类如下：

    public class Student {
        private String name;
        private int age;
        private String address;
        public void eat(){
            System.out.println("吃饭");
        }
        public void sleep(){
            System.out.println("睡觉");
        }
        public void haveClass(){
            System.out.println("上课");
        }
        public void setName(String name1){
            name=name1;
        }
        public void setAge(int age1){
            age=age1;
        }
        public void setAddress(String address1){
            address=address1;
        }
        public String getName(){
            return name;
        }
        public int getAge(){
            return age;
        }
        public String getAddress(){
            return address;
        }
    }

   这样我们就可一通过定义的public类型的方法来获取和修改Student类中成员变量的值，当然我们可以在这些方法中添加一些限制条件，例如，让年龄的范围控制在0-99之间，修改后的setAge()方法如下：

        public void setAge(int age1){
            if(age1>=0&&age1<=99){
                age=age1;
            } else{
                ;
            }
        }

8.this 关键字

当我们的局部变量和成员变量相同的时候,如果我们不使用this关键字,那么会导致一个问题:就是局部变量隐藏了成员变量的问题。那么this就帮我解决了这个问题。我们在遇到局部变量隐藏成员变量的时候就可以使用this关键字。简单地说，this代表当前类的一个对象，谁调用这个方法，那么该方法的内部的this就代表谁。

例如在我们的Student类中，我们定义setXX()和getXX()方法时，不能将参数名和成员变量名设置为相同，因为这样就会发生局部变量覆盖成员变量，所以我们引入this关键字就可以解决这个问题。

修改后的Student类的代码如下：

 public class Student {
     private String name;
     private int age;
     private String address;
     public void eat(){
         System.out.println("吃饭");
     }
     public void sleep(){
         System.out.println("睡觉");
     }
     public void haveClass(){
         System.out.println("上课");
     }
     public void setName(String name){
         this.name=name;
     }
     public void setAge(int age){
         this.age=age;
     }
     public void setAddress(String address){
         this.address=address;
     }
     public String getName(){
         return name;
     }
     public int getAge(){
         return age;
     }
     public String getAddress(){
         return address;
     }
 }