面向对象

2020-04-19 本文已影响0人雪上霜

面向对象和面向过程区别：
- 从语言出发：
  - C：完全面向过程
  - C++：一半面向过程，一半面向对象
  - Java：完全面向对象
- 开发方式：
  - 面向过程
    - 注重实现功能步骤，注重实现功能的因果关系。
    - 第一步干什么，第二步干什么。
    - 缺点：耦合度高，扩展能力差。
    - 优点：对于小型项目，效率高
    - 采用面向过程开发一台计算机：一体机
    - 采用面向对象开发一台计算机：组合机
  - 面向对象
    - 将现实世界分隔成不同的单元，然后每一个单元实现成对象，然后给一个环境驱动一下，让各个对象之间写作起来形成。（更符合人类思维方式）
    - 优点：耦合度低，扩展性高
- 面向过程主要关注的是：实现步骤以及整个过程
- 面向对象主要关注的是：对象A，对象B，对象C。。。然后进行组合。
- OOA：面向对象分析
- OOD：面向对象设计
- OOP：面向对象编程
- 实现软件过程：分析（A)->设计（D)->编程（P)。
- leader 领导、组长
- team 团队
- PM 项目经理 Project Manager
- 面向对象三大特征：封装、继承、多态
类和对象
- 主要一词：对象
- 类：是一个抽象的概念，一个模板，是思考、总结、抽象的一个结果。本质是现实世界中的某些食物的共同特征，提取出来的一个概念，一个模板。
- 对象（实例）：实际存在的实体。
- 要想得到对象，必须先定义类，对象是通过类这个模板创造出来的。
- 类是一个模板：类中描述所以对象的共同特征信息。
- 对象是通过类创建出的个体。
- 通过类创建对象的过程叫实例化。
- 抽象：多个对象具有共同特征，进行思考总结抽取特征的过程。
- 类：包括：状态特征（属性）、动态特征（方法）
- ```
public class Student{
    //属性：
        姓名
        性别
        身高
    //方法
        sing
        dance
        study
}
```
- 要求具备：观察+抽象能力，把现实世界中的对象手中的共同特征抽象成类，然后通过类实例化对象，让对象之间互相写作形成系统，模拟现实世界。

image.png

类的定义
- ```
[修饰符列表] class 类名{
    //类体=属性+方法
    //属性在代码中以变量形式存在（描述状态）。
    //方法描述动作行为。
}
```
- 因为属性是数据，数据在程序中存在变量中。
- 变量：在方法体内声明：局部变量；类内方法体外声明变量：成员变量（属性）。
- 成员变量可以不手动赋值。
- ```
public class Student{
    int id;
    String name;
    int age;
    boolean gender;
    String addr;
}
```
- ```
public class StudentTest{
    public static void main(String[] args){
        //new 类名()； 创建对象。
        //new是一个运算符，专门负责对象的创建。
        //类型 变量名 = new 类名();
            //s1叫引用
        Student s1 = new Student();
        //类型：基本数据类型+引用数据类型。
        //Java中所有的类都属于引用数据类型。
    }
}
```
- 创建对象的个数没有限制，只要有模板类就行。
- 关于编译的过程：按说先编译Student.java ,再编译StudentTest.java。
- 但是对于编译器来说，编译StudentTest.java时，会自动找Student.class文件，如果没有，会自动编译Student.java文件，生成Student.class文件。
- 第一种方式：javac Student.java javac StudentTest.java
- 第二种方式：javac StudentTest.java
- 第三种方式：javac *.java
- 在语法上实现对象创建：类名变量名 = new 类名();

image.png

成员变量没有手动赋值都默认赋值。
- 类型默认值
- byte 0
- short 0
- int 0
- long 0L
- float 0.0F
- double 0.0
- boolean false
- char \u0000
- 引用数据类型 null
实例变量（属性）：对象级别的变量。
实例变量访问时，必须先实例化。不能通过类名直接访问。

image.png

对象和引用的区别：对象是通过new出来的，在堆内存中存储。引用是但凡是变量并且变量中保存了堆内存中对象的变量。
//访问实例变量: 引用.实例变量名

public class 学生{
  int 学号;
  String 姓名;
}

public clss 学生测试{
  public static void main(String[] args){
      学生 张三 = new 学生();
      System.out.println(张三.学号);
      System.out.println(张三.姓名);
      
      张三.学号 = 111;
      张三.姓名 = "这里";
      
      System.out.println(张三.学号);
      System.out.println(张三.姓名);
  }
}

public  class User{
    int id;
    String user;
}

public class UserTest{
    public static void main(String[] args){
        User u1 = new User();
        u1.id = 111;
        u1.user = "张三";
        
        System.out.println(u1.id);
        System.out.println(u1.user);
    }
}

image.png

借鉴：

image.png

public class Addr{
    String city;
    String jd;
}

public class User{
    String username;
    int id;
    Addr addr;
}

public class Test{
    public static void main(String[] args){
        User u = new User();
        System.out.println(u.id);
        System.out.println(u.username);
        System.out.println(u.addr);
        
        Addr c  = new Addr();
        c.city = "beij";
        c.jd = "daxing";
        
        u.addr = c;
        
        System.out.println(u.addr.city);
    }
}

image.png

画内存图注意事项：
- 不要体现代码在内存图中，主要体现数据
- 图形，有先后顺序。
为什么画内存图
- 有了内存图，程序不允许，也知道结果
- 有了内存图，有助于调试程序
引用是存储对象内存地址的一个变量
对象是堆里new出来的。
引用一定是局部变量吗？不一定。可以是成员变量

public class T{
    A a;
    
    public static void main(String[] args){
        D d = new D();
        C c = new C();
        B b = new B();
        A a = new A();
        T t = new T();
        
        //以下赋值不写会出现空指针异常。
        c.d = d;
        b.c = c;
        a.b = b;
        t.a = a;
        
        //通过t访问d中的i
        System.out.println(t.a.b.c.d.i);
    }
}

class A{
    B b;
}
class B{
    C c;
}

class C{
    D d;
}
class D{
    int i;
}

public class NullPointerTest{
    public static void main(String[] args){
        Customer c = new Customer();
        
        System.out.println(c.id);
        
        c.id = 9876;
        System.out.println(c.id);
        
        c = null;//编译器只检查语法。语法没错。
        System.out.println(c.id);
    }
}

class Customer{
    int id;
}

image.png

关于垃圾回收器GC：在Java中，垃圾回收期主要针对的是堆内存。当一个Java对象没有任何引用指向该对象时，GC会考虑将该垃圾数据释放回收掉。
空引用访问实例（对象相关）相关的数据时都会出现空指针异常。

  public class Test{
    public static void main(String[] args){
        int i = 10;
        add(i);
        System.out.println("main-->"+i);
    }
    public static void add(int i){
        i++;
        System.out.println("add->"+i);
    }
  }

360截图20200417112338296.jpg

无论是基本数据类型还是引用数据类型传值都是值传递

public class Test{
    public static void main(String[] args){
        Person p = new Person();
        p.age = 10;
        add(p);
        System.out.println("main->"+p.age);
    }
    public static void add(Person p){
        p.age++
        System.out.println("add->"+p.age);
    }
}

class Person{
    int age;
}

image.png

值传递传递的是变量中保存的值复制一份传递过去。
构造方法：通过构造方法可以完成对象的创建以及实例变量初始化。也就是说，构造方法是用来创建对象并且同时给对象的属性赋值。
当一个类没有提供任何构造方法，系统默认提供一个无参构造方法。
建议将无参构造写出来。
调用构造方法使用new运算符

// 构造方法语法：
[修饰符列表]构造方法名(形式参数列表){
  构造方法体;
}
修饰符目前统一写public
构造方法与类名必须一致。
构造方法不需要指定返回值类型，也不能写void。写void表示普通方法。
//普通方法语法：
[修饰符列表]返回值类型 方法名(形式参数列表){
  方法体;
}

//构造对象
new 构造方法名(参数列表);

public class ConstructorTest{
  public static void main(String[] args){
      Student s1 = new Student();
      //如果定义了一个有参构造，则系统不会提供无参构造方法。
      
      System.out.println(s1);
      
      Student s2 = new Student(2);
      
      Student s3 = new Student(1,"11",12);
      
      System.out.println(s3.id);
      System.out.println(s3.name);
      System.out.println(s3.age);     
  }
  
  public static void doSome(){
      System.out.println("111");
  }
}

public class Student{
  int id;
  string name;
  int age;
  
  public Student(){
      System.out.println("do some!");
  }
  public Student(int i){
      
  }
  
  public Student(String name){
      
  }
  public Student(int id,String name,int age){
      id = id;
      name = name;
      age = age;
  }
}

成员变量默认赋值的时机：在构造方法执行的过程中完成的初始化。
构造方法：用于对象的创建
封装作用：保证内部结构的安全；屏蔽复杂，暴露简单。

在代码级别上，封装有什么用？

一个类中的数据，假设封装之后，对于代码的调用人员来说，不需要关心代码的复杂实现，只需要通过一个简单的入口就可以访问了，另外，类体重安全级别较高的数据封装起来，外部人员不能随意访问，来保证数据的安全性。
```
public class Person{
    int age;
}
```

public class PersonTest{
    public static void main(String[] args){
        Person p1 = new Person();
        System.out.println(p1.age);
        
        p1.age = 50;
        System.out.println(p1.age);
        
        p1.age = -100;//age是一个负数，但是通过了。
        System.out.println(p1.age);
        
    }
}

//不使用封装Person类的age暴露，随意修改。

//封装起来，数据安全，调用方便
//属性私有化，对外提供简单的操作
public class PersonTest{
    public static void main(String[] args){
        Person p1 = new Person();
        System.out.println(p1.age);
        
        p1.age = 50;
        System.out.println(p1.age);
        
        p1.age = -100;//age是一个负数，但是通过了。
        System.out.println(p1.age);
        
    }
}

public class Person{
    private int age;//只能在本类中访问，出来就不能访问了。
    
    //外部访问入口
}

构造方法作用：创建对象，给属性赋值。

public class MethodTest{
    public static void main(String[] args){
        //调用static的调用方法
        MethodTest.doSome();
        doSome();
        
        //不带static的调用方法
        MethocTest mt = new MethodTest();
        mt.doOther();
    }
    //带static方法
    public static void doSome(){
        System.out.println("wss");
    }
    
    //无static方法,实例方法，必须通过对象调用
    public void doOther(){
        
    }
}

//空指针异常本质是空引用访问实例相关数据。
public class NullPointerTest{
    public static void main(String[] args){
        User u = new User();
        System.out.println(u.id);
        u.doSome();
        
        u = null;
        System.out.println(u.id);//需要对象存在，空指针异常
        u.doSome();//一个实例方法调用必须有对象的存在，所以空指针异常。
    }
}

class User{
    int id;
    public void doSome(){
        System.out.println("dosome");
    }
    public void exam(){
        
    }
}

public class Person{
  private int age;//只能在本类中访问，出来就不能访问了。
  
  //外部访问入口
  //提供对外公开的入口，都是类的实例操作入口，因此非static类型的。
  //set和get的格式： 
  //public 返回值类型 get+属性首字母大写(无参){
      return xxx;
  //}
  //public void set+属性首字母大写(参数){
      xxx = 参数;
  //}
  public int getAge(){
      return age;
  }
  public void setAge(int nianLing){
      if(nianLing < 0 || nianLing > 150){
          System.out.println("年龄值不合法");
          return;
      } 
      age = nianLing;
  }
}

public class PersonTest{
    public static void main(String[] args){
        Person p = new Person();
        int nianLing = p1.getAge();
        System.out.println(nianLing);
        
        
        p1.setAge(100);
        System.out.println(p1.getAge());
        
        p1.setAge(-100);
        System.out.println(p1.getAge());
    }
}

封装的代码实现：属性私有化；对外提供set和get方法。
set和get都是实例方法，不带static，实例方法必须先new对象。

面向对象

猜你喜欢

热点阅读