实训知识整理记录 第二周

实训记录第二周

在另外一个教学视频接触了markdown编辑器，本周的笔记就尝试用新的编辑器来记录，当然还不是很熟悉，用了后发现有一些错用，比如引用被我用来记录一些小的注意点，以后慢慢改正，还是基础，就这样吧。

model 4 Array 数组

一. 数组描述

1. 数组是一组具有相同数据类型的集合。
2. 数组是一个对象（用来存放数据的对象）。
   
   • 属性（成员/元素）:length,每一个数据都是数组的一个成员。
3. 数组一旦声明，数组变量所指向的数组的数据类型就固定了。创建数组相当于创建对象。java中创建对象使用new。
4. 创建数组的时候一定要显式或者隐式的指明数组长度。数组长度一旦固定不能更改。在内存空间中分配连续的空间进行存储。
5. 数组是对象，数组中的成员(除了length)都会使用默认的初始值进行初始化
6. 数组给除了length之外的每一个数据元素一个唯一的数字标识，我们称之为索引（下标）。访问数据时可以使用数组变量名[index]，index从0开始到数组长度-1。
7. 因为数组空间连续并且可以使用有序的索引值来随机访问，所以可以通过index值来精确控制数据在数组中的存放位置。借助数组来实现有序的线性结构。

二.声明数组

• 语法：

  DateType[] varName; 推荐

  DateType vvarName[];

  声明数组仅仅表明声明了一个存放某一种数据类型的数组变量。所以声明一定不指定length。

三.数组的创建

• 语法

  new DateType[length];
  

  • 创建数组时创建了一个对象，所以使用new操作。并且一定要显式告诉虚拟机你要申请多大的空间存放
  • 创建数组之后，数组的length属性值就固定了。数组中的成员变量使用默认初始值初始化
  • 下标0 ~ length-1
  • length一定是一个int类型的正整数（包括0）。
    

  note:

String[] args 如无参数，虚拟机自动构建长度为0的String数组传给args。

四.数组的初始化

1. 动态初始化

   Student[] stu = new Student[1];
   int[] a = new int[1];
   a[0]=10;
   stu[0] = new Student();`
   

2. 静态初始化

   int[] a = {1,2,3,4,5};

3. 错误的初始化格式

   int[] a;
   a = {};
   a = new int[5]{...};
   

五.数组的基本操作：

1. 数组长度：varName.length
2. 数组数据的访问：varName[index]

3. 数组遍历：varName[index]

   1. 初始状态>>index=0
   2. 循环结束状态>>index=length-1
   3. 状态变化 index++

       for(int index=0;index<varName.length;index++){
           use(varName[index]);
       }
   

   • 练习1: 定义一个方法，能够计算给定数组数据的平均值

     public static double getAvg(int[] values){
         int sum=0;
         for(int i=0;i<values.length;i++){
             sum+=values[i];
         }
         double result = sum/values.length;
         return result;
     }
     

   • 练习2: 定义一个方法，得出数组数据的最大值

     public static int getMax(int[] values){
         int max = values[0];
         for(int i=1;i<values.length;i++){
             if(max<values[i]){
                 max=values[i];
             }
         }
         return max;
     }
     

4. 增加，删除，修改，查找(随机访问，按照index取值)

   • 增加 数组拷贝

     System.arrayCopy(src,srcPos,dest,destPos,length);

   • int[] a={1,2,3};
   • int[] b=new int[a.length+5]

5. 数组的排序

   • 冒泡排序：
   • 选择
   • 插入

6. 数组查找（根据值查找值的索引位置）

   • 有序数组（按照数据的大小顺序有序）
     
     • 折半查找

六. 工具类 Arrays

• binarySerach
• sort
• copyOf
• copyOfRange

七. 多维数组：存放数组的数组

• 语法：DataType[ ][ ] varName;
• 二维数组
  
  • 声明：DataType[][] varName;
  • DataType varName[][];
  • DataType[] varName[];
• 创建二维数组：
  
  • varName = new dataTypep[length1][length2];
    
    • length1必须存在
    • 若length2存在，那么默认varName[index]是进行了显式初始化的，每一个都是长度为length2的一维数组
    • 若length2不存在，那么varName[index]都是默认初始值null
• 初始化
  
  • varName[index1][index2] = value;
  • varName[index1] = new DataType[length2];
  • varName[index1] = new DataType[]{…};
  • DataType[][] varName = {{…},{…},{…}};
    
    • 练习 初始化一个二维数组如下
      
      • 0 2 2 2 2
      • 1 0 2 2 2
      • 1 1 0 2 2
      • 1 1 1 0 2
      • 1 1 1 1 0

八. 可变长参数(jdk5.0)

• 如果方法体不能够确定接受的参数个数，那么方法体在声明时可以使用数组，但如果变量为数组类型，那么要求在调用方法执行前必须显式执行数组的创建。jdk5.0引入了可变参数，用…代替原来数组的[],…只能出现在数据类型之后。(int… a),那么在调用方法执行时可以不用显式的创建数组对象，编译器会自动将传递过来的所有参数构建成数组对象。

  • 定义一个方法，用来计算用户输入的所有数的和。

    1 如果方法体上有可变长参数声明，必须位于参数列表最后一个。

    2 一个方法体只能有一个可变长参数。

    3 main方法的方法签名中定义的String[] args也可以使用可变参替换。
    public static void main(String... args)

九. 格式化输出

• System.out.printf(String format,Object…args)

  • String format%[index]

  odxf mYe

model 5 类和对象

面向对象思想

1. 
   
2. 对象
   
   • 全部抽象为对象
   • 每个对象唯一
   • 每个对象都是某一类型的实例。
3. 类
   
   • 抽象的数据类型。抽象对象所具有的共有特征(属性)和行为。
     
     • 属性：变量
     • 行为：方法
   • 元数据。描述数据的数据
   • 类是对象的模板(抽象)
   • 类用来描述一个范围的对象
   • 面向对象的编程的主要任务就是定义类。

4. 定义类(根据对象抽象类的过程)

[modifers] class className [extends superClass][implements inter1,inter2,...]{
    成员变量:
        1. 实例变量：依赖于实例存在。(表现为未使用static修饰)
            访问：对象名.变量名
        2. 类变量：static修饰，类存在变量即存在。被所有类的实例共享。
            访问：类名.变量名
    成员方法:
        1. 实例方法：依赖于实例对象存在才能被调用的方法。
            访问：对象名.方法名
        2. 类方法：类存在即存在。
            访问：类名.方法名
                Math.random()
    构造器：
    内部类：
}

    note:方法
    * 方法定义必须有返回类型的声明，无返回值使用void
    * 一个方法只能有一个返回值
    * 如果方法声明了返回类型，要求必须有return操作
    * 方法的定义不能嵌套

• 参数传递

  • 形参：形式参数。跟在方法定义id小括号中，用来接收用户在调用方法的过程中实际参与运算的值。(作用范围，局部变量)

  • 实参：实际参与运算的值。方法调用过程中，由调用者传递过来的数据。

  • java中参数传递都是值传递。

    • 基本数据类型：字面值(值传递)
    • 引用类型：地址值(引用传递)

• 方法重载

  • 定义：

    1. 定义在同一个类中
    2. 方法名相同，参数列表不同
       
       1. 参数类型
       2. 参数个数
       3. 参数顺序

    3. 跟返回类型无关(返回类型可以相同也可以不同)

       • note：
         

       1. 重载的方法在匹配过程中，先精确，后模糊。优先匹配类型一致，如果类型不能匹配在模糊查找。匹配先匹配规定参数长度的方法，再匹配具有变长参数的方法。
          
       2. 如果有多个方法匹配报错(注意可变长参数)

• 构造器：用来构建对象的操作过程
  

  • 用法：new constructor()
  • 定义：
    [modifer]className(DataType param,...)[throws Exception]{}
    
    • note:
      

  1. 构造器只是构建对象，对对象进行初始化操作，一定没有返回类型，不添加任何返回值描述，包括void
     
  2. 构造器名一定和类名相同
     
  3. 如果类中没有显式的定义构造器，那么虚拟机会提供一个默认构造器，如果在类中自定义了构造器，默认构造器将不再提供
     
  4. 构造器可以被重载用来调用当前类的实例变量
     
  5. 构造器之间可以相互调用。调用方式this(param,…),被调用构造器的调用一定位于调用构造器的第一行

• this关键字：当前对象的引用，，实例方法以及实现构造器之间的相互调用

• 对象的创建以及初始化过程：

      Class Person{
          String name;
          int age = 10;
          public Pserson(String name,int age){
              this.age = age;
              this.name = name;
          }
          public static main(String[] args){
              Person p = new Person("张三",9);
          }
      }
  

  1. 创建对象(在堆区申请内存空间)，同时构建实例变量，并且对实例变量使用默认初始值进行初始化。
  2. 看实例变量是否有进行显式的初始化操作，如果有，修改实例变量的值为指定值。
  3. 调用构造器

  面向对象编程的特征：封装，继承，多态

• 封装：

  • 目的：为了实现信息的隐藏，行为实现细节的隐藏
  • 实现方式：缩小访问权限(private,protect…)
  • 过程：定义类的过程
  • 好处：维护数据安全，保证数据的一致性，缩小范围后，提供统一的入口，对象之间的交互变得可控

• 继承

  • 目的：代码复用，简化构建过程。

    class subclass extends superclass

    1. Java中的继承为单继承
    2. 继承后衍生类可以继承基类具有的属性和行为(权限允许范围之内)
    3. 衍生类可以添加自己的属性和行为
    4. 构造器不能被继承
    5. 如果有继承关系存在，衍生类一定会显式或者隐式的调用基类的构造器，默认情况下一定会隐式的调用基类的无参构造器，如果基类不存在无参构造器，那么衍生类构造器必须显式的调用父类构造器。
    6. this调用当前类的构造器和super调用基类的构造器不可能同时出现
    7. 衍生类可以出现和基类同名的变量，也可以覆盖基类的方法

• super关键字

  • super代表基类
  • super可以引用基类的属性行为和构造器，衍生类构造器对基类构造器的引用必须位于衍生类构造器的第一行。

• 方法的重写

  • 发生在继承关系中，衍生类具有和基类相同的方法
  • 方法签名完全一致(方法名，返回类型，参数列表)
  • 访问权限不能被缩小
  • 异常不能被扩大
  • static修饰的方法不能被重写为非static的方法

• 数据类型转换

  • 引用数据类型之间的转换

    1. 隐式数据类型转换：基类类型引用指向衍生类对象

       • 衍生类向基类转，隐式数据类型转换

         Animal an = new Cat();

    2. 显式数据类型转换：

       • 基类向衍生类转换

         Cat c = (Cat)an;将基类的值赋值给衍生类的应用，需要强制类型转换。在强转时只要符合语法要求，编译可以通过但不排除运行异常ClassCastException。为了避免异常的产生，在转换前，应先判断一下要转换的基类类型的引用变量所带表的对象是否是想要转换的类型的对象。(可用instanceof判断，为true可转)

• 多态
  
  • 编译时多态
    
    • 方法的重载
  • 运行时多态
    
    • 方法的重写(实例方法会有多态的体现)
      *相同基类的衍生类在调用相同方法时的表现不同
      

      要求：
      
      1. 有继承关系
      2. 衍生类重写了基类的行为
      3. 有基类类型的引用指向衍生类的对象
      4. 调用了被重写的方法