Java基础复习---第三章

Posted 2020-08-10

第三章

面向对象

面向对象更加强调运用人类在日常的是为逻辑中采用的思想方法与原则

抽象、分类、继承、聚合、多态

面向对象与面向过程

? 面向过程：强调的是功能行为

? 面向过程：将功能封装进对象，强调具备了功能的对象

面向对象三大特征

? 封装、继承、多态

OOP思想概述

类 ：对现实世界事物的抽象定义

对象：类的实体（实例）

?

? ps. 类就像汽车设计图 对象就像实际的汽车

? 类(class)和对象(object)是面向对象的核心概念。类是对现实世界事物的描述，类是抽象、概念上的定义。

? 面向对象的开发方式：

• 先找具有所需功能的对象
• 对象不存在时创建所需功能的对象
• 面向对象简化开发提高代码复用
• 面向对象程序设计的重点：类的设计
• 定义类其实是定义类中的成员（成员变量、成员方法）

类

定义类其实是定义类中的成员（成员变量、成员方法）

类的定义

public class Teacher{
  
  String name;
  int age;
  String gende;
  
  public void teach(){
    System.out.println("老师上课")；
  }
  
  public void eat(){
    System.out.println("老师吃饭")；
   }
  
   public void introduce(){
        System.out.println("姓名："+name+“年龄”)
    System.out.println("年龄:"+age);
    }
 }

类的属性

描述事物的特征

? 属性用来描述事物的特征，用属性变量来保存数据，属性也叫做成员变量，分为两类：

• 对象属性(实例属性):隶属于对象，以来于对象存在而存在
• 类属性(类变量)：类中的静态属性

? 类中定义的成员变量。

示例：
    public class Student{

    public int source;
    private String name;
    private int age;
    private char sex;
    //成员变量、对象属性、类属性
    ...
  }

类的方法

? 方法也叫做成员方法，分为两类：

• 对象方法(实例方法)：隶属于对象通过对象来调用，内部用this调用。
• 类方法：隶属于类，通过该类即可访问

? 类中定义的方法。

示例：
    public class Teacher{

    String name;
    int age;
    String gende;

        //以下为类中定义的方法
    public void teach(){
      System.out.println("老师上课")；
    }

    public void eat(){
      System.out.println("老师吃饭")；
     }

    public void introduce(){
      System.out.println("姓名："+name+“年龄”)
      System.out.println("年龄:"+age);
    }
   }

访问属性和方法

? 通过对象访问属性和方法，使用对象加.的方式。

对象创建（简单了解）

? 通过new关键字可以将一个类进行实例化，实例化即创建某个类的对象，类的实例即是一个对象。

//  Techer类型        对象的引用     new关键字      构造方法
        Teacher          teacher    =   new          Teacher();

访问方法及属性

? 通过对象加上.的方式访问对象的方法或属性非private属性

示例：
  public class TeacherTest{
  public static void main(String[] args){
    
    //创建对象teacher
    Teacher teacher = new Teacher();
    
    //给teacher对象的属性赋值
    teacher.name = "王欢"；
    teacher。age = "24";
    
    //调用teacher对象的 teach() 方法
    teacher.teach();
  }
}

示例

示例一 打印日期

? 创建文件MyDate.java

  public class MyDate{
            
        int year;
        int month;
        int day;
    
    public String getMyDate(){
      return year+"年"+month+“月”+day+"日"；
    }
  }

? 创建测试类 MyDateTest.java

public class MyDateTest{
  public static void main(String[] args){
    
    MyDate myBirthDay = new MyDate();
    myBirthDay.year  = 1995;
    myBirthDay.month = 8;
    myBirthDay.day   = 17;
    
    MyDate today = new MyDate();
    today.year  = 2019;
    today.month = 4;
    today.day       = 16;
    
   System.out.println("生日:"+myBirthday.getMyDate());
   System.out.println("今天:"+today.getMyDate());
  }
}

示例二 实例与引用

封装性

? 将类的成员变量私有化，使用get、set方法读取和设置成员变量的值，体现了类的封装性，保护数据。

• 隐藏一个类中不需要对外提供的实现细节
• 使用者只能通过实现定制好的方法来访问数据
• 便于加入控制逻辑，限制对属性的不合理操作
• 便于修改，增强代码的可维护性

//示例：getter、setter方法
  public class Dog{

      private String  color;
      private String  name;
      private int     age;

      public void cry(){
          System.out.println("狗狗叫呢！");
      }

      public String eat(String something){
          return "狗吃了"+something;
      }

      public  void  say(){
          System.out.println("狗会说话了？");
      }

      public String getColor() {
          return color;
      }

      public void setColor(String color) {
          this.color = color;
      }

      public String getName() {
          return name;
      }

      public void setName(String name) {
          this.name = name;
      }

      public int getAge() {
          return age;
      }

      public void setAge(int age) {
        if（age<20&&age>0）
          this.age = age;
        else return;
      }
  }

匿名对象

? 实例化对象后直接使用，没有使用对应的引用变量进行接收。适用于对象实例化只需要进行一次调用的请情况下，调用完成对象将由GC垃圾回收进行处理。

? new Teacher().eat();

构造器

创建对象 初始化对象

? 对象的构造器用于创建对象，在创建对象时完成对象的初始化工作。构造器(构造方法)在创建对象时由JVM执行。

构造器特征

• 构造器名与类名相同
• 不用声明返回值
• 不能为使用static、final、synchronized、abstract、native修饰
• 不能由return语句返回值

示例

  public class Dog{

    private String color;
    private String name;
    private int age;

    public Dog(){}//无参构造器
    //当类中未编写构造器时默认有一个 无参构造器
    //当编写了有参构造器时，默认没有 无参构造器 按需自行编写它
    
    //带参数构造
    public Dog(String color, String name, int age){
      this.color = color;
      this.name  = name;
      this.age   = age;
    }
    
    //构造器也是类方法 可以重载
    public Dog(String color,String name){
      this.color    = color;
      ths.name      = name;
    }
        ...
  }

  public class Dog{

    private String color;
    private String name;
    private int age;

    public Dog(){
      this("白色","小白")；
      //必须放在首行！  
    }
    //无参构造器
    //当类中未编写构造器时默认有一个 无参构造器
    //当编写了有参构造器时，默认没有 无参构造器 按需自行编写它
    
    //带参数构造
    public Dog(String color, String name, int age){
      this.color = color;
      this.name  = name;
      this.age   = age;
    }
    
    //构造器也是类方法 可以重载
    public Dog(String color,String name){
      this.color    = color;
      ths.name      = name;
    }
        ...
  }

? ps. 一般类中保留两个构造器，一个无参构造器和一个全参数构造器。

?

JavaBean

JavaBean是一个普通的Java类

? JavaBean是一种Java语言写成的可重用组件。用户可以使用JavaBean将功能、处理、值、数据库访问和其他人户可以用java代码创造的对象进行打包，并由其他开发者在其他功能中使用这些对象。

? JavaBean提供了一种随时随地的复制和粘贴的功能，不用关心任何改变。

? JavaBean标准

• 类是公共类型
• 类中含有公共无参构造器
• 有属性并由对应的getter、setter方法

示例：
//Computer.java 
    public class Computer {

      private double cpu;
      private int memory;

      public Computer() {
      }
     
      public double getCpu() {
          return cpu;
      }

      public void setCpu(double cpu) {
          this.cpu = cpu;
      }

      public int getMemory() {
          return memory;
      }

      public void setMemory(int memory) {
          this.memory = memory;
      }
  }

包 package

package语句规范类的整理 解决类名冲突问题

? package语句应放在java源文件的第一行。

//package 包名.子包名.子子包名.子子子包名
//            组织.机构名称.项目名称.模块名称
//              org、com、edu
package org.apache.oracle.JdbcDriver

• package关键字使用后编译java文件时命令需要使用java -d . *.java

• 其他类中使用需要使用类全限定名称org.apache.orcle.JdbcDriver

包 import

import语句告诉编译器到哪里去寻找类

? 为使用定义在不同包中的Java类，需用·import语句来引入指定包层次下所需要的类或全部类。

//import  包名.子包名.子子包名.子子子包包.类名(或 [表示全部]) 

  import  org.apache.oracle.JdbcDriver;
  import    org.apache.oracle.*;

数组

? 数组是一组相同类型的数据的集合，数组是对象。元素是数组中的一个数据，任意类型的数据都可以创建数组。

• 数据多个形同类型数据的组合，实现堆这些数据的统一管理
• 数组中的元素可以是任何数据类型(基本数据类型、引用类型)
• 数组是引用类型，数组型数据是对象。
• 数组中每个元素相当于该对象的成员变量。

声明数组

示例：
    int[] intArray;
    //声明了一个int数组
    intArray = new int[5];
    //创建数组：使用new关键字 中括号内数字表示元素个数
    //数组一旦创建长度和数据类型将无法再被修改

    intArray[0] = 11;
    intArray[1] = 22;
    intArray[2] = 33;
    intArray[3] = 44;
    intArray[4] = 55;

//以下语句编译无报错但运行时会报错IndexOoutOfBoundsException
//intArray[5] = 666;

? ps.数组在内存中时是连续 数组长度过大可能会创建失败

循环写读

示例：
    int[] intArrays = new int[5];
    
    //循环赋值
    for(int i=0; i<5; i++){ 
        intArrays[i] = i;
  }
    
    //循环遍历
    for(int i=0; i<intArrays.length; i++){
    //intArrays.length是数组的长度    length是常量不可修改
    System.out.println(intArrays[i]);
    }

    //增强for循环遍历
    //  局部变量       待遍历数组
  for(int intArray:intArrays){
    System.out.println(intArray);
  }

初始化数组

示例： 
    //动态初始化
  int[] intArrays = new int[3];
  intArrays[0] = 1;
  intArrays[1] = 11;
  intArrays[2] = 111;

    //静态初始化
    int[] intArrays = new int[]{1,11,111};
    
    int[] intArrays；
    intArrays = new int[]{1,11,111}; 
    
    int[] intArrays = {1,11,111};
    
    //int[] intArrays；
    //编译报错intArrays = {1,11,111}; ×
    
    //以下写法编译报错
    //int[] intArrays = new int[6]{1,11,111};   ×

对象数组

示例：
    
    Cat[] cats = new Cat[3];
    cats[0] = new cat("灰灰")；
//cats[1] = new Cat("靓靓")；
    cats[2] = new Cat("花花");

  for(Cat cat:cats){
    cat.say();
  }
    //cats[2] 未实例化运行时报错空指针异常 
    //NullPointerException