Unit02-OOP-对象和类，数组（下）

　　　　Unit02-OOP-对象和类，数组（下）　　　　

1.方法的签名: 方法名+参数列表

2.方法的重载(Overload):
  1)发生在一个类中，方法名称相同，参数列表不同
  2)编译器在编译时自动根据签名绑定调用不同的方法

3.构造方法:
  1)常常给成员变量赋初值
  2)与类同名，没有返回值类型
  3)在创建(new)对象时被自动调用
  4)若自己不写构造方法，则编译器默认一个无参构造方法，
    若自己写了构造方法，则编译器不再默认提供
  5)构造方法可以重载

4.this:指代当前对象，哪个对象调指的就是哪个对象
       只能用在方法中，方法中访问成员变量之前默认都有个this.
  this的用法:
    1)this.成员变量名------访问成员变量
    2)this.方法名()--------调用方法
    3)this()---------------调用构造方法

5.引用类型数组:
  1)Cell[] cells = new Cell[4]; //创建格子数组对象
    cells[0] = new Cell(2,5); //创建格子对象
    cells[1] = new Cell(2,6);
    cells[2] = new Cell(2,7);
    cells[3] = new Cell(3,6);
  2)Cell[] cells = new Cell[]{
      new Cell(2,5),
      new Cell(2,6),
      new Cell(2,7),
      new Cell(3,6)
    };
  3)int[][] arr = new int[3][];
    arr[0] = new int[2];
    arr[1] = new int[3];
    arr[2] = new int[2];
    arr[1][0] = 100; //arr中第2个元素中的第1个元素赋值为100
  4)int[][] arr = new int[3][4]; //3行4列
    for(int i=0;i<arr.length;i++){
      for(int j=0;j<arr[i].length;j++){
        arr[i][j] = 100;
      }
    }

嵌套数组：
3为arr的长度
4为arr中每个元素的长度

int[][] arr = new int[3][4]; //3行4列
for(int i=0;i<arr.length;i++){
  for(int j=0;j<arr[i].length;j++){
    arr[i][j] = 100;
  }
}

i=1
  j=0 arr10
  j=1 arr11
  j=2 arr12
  j=3 arr13

//声明整型数组的数组arr，包含3个元素
//每个元素都是int[]型，默认值为null
int[][] arr   = new int[3][];
arr[0] = new int[4];
arr[1] = new int[4];
arr[2] = new int[4];
//给arr中第2个元素中的第1个元素赋值为100
arr[1][0] = 100;

arr-----------------int[][]
arr[0]--------------int[]
arr[0][0]-----------int

//声明整型数组arr，包含4个元素
//每个元素都是int类型，默认值为0
int[] arr = new int[4];

//声明Cell型数组cells，包含4个元素
//每个元素都是Cell型，默认值为null
Cell[] cells = new Cell[4];

//声明Student数组stus，包含26个元素
//每个元素都是Student型，默认值为null
Student[] stus = new Student[26];

一个类，肯定有构造方法-----对
自己可不可以不写构造-------可以
                            写了更方便
成员变量：
class Student{
  String name;
  int age;
  String address;
  Student(){
  }
  //给成员变量赋初值
  Student(String name1,int age1,String address1){
    name = name1;
    age = age1;
    address = address1;
  }
}

基本类型数组

引用类型数组

演示方法的重载

package oo.day02;
/*
 * 补充:
 * 1.一个文件中可以包含多个类
 * 2.public修饰的类只能有一个
 * 3.public修饰的类必须与文件名相同
 */
//演示方法的重载
public class OverloadDemo {
    public static void main(String[] args) {
        Aoo o = new Aoo();
        o.say();
        o.say("zhangsan");
        o.say("zhangsan", 25);
        o.say(25, "zhangsan");
    }
}

class Aoo{
    void say(){}
    void say(String name){}
    void say(String name,int age){}
    void say(int age,String name){}

    //int say(){return 1;} //编译错误，重载与返回值类型无关
    //void say(String address){} //编译错误，重载与参数名称无关
}

//引用类型数组

package oo.day02;
//引用类型数组
public class RefArrayDemo {
    public static void main(String[] args) {
        Cell[] cells = new Cell[4]; //创建格子数组对象
        cells[0] = new Cell(2,5); //创建格子对象
        cells[1] = new Cell(2,6);
        cells[2] = new Cell(2,7);
        cells[3] = new Cell(3,6);

        Cell[] cs = new Cell[]{
            new Cell(2,5),
            new Cell(2,6),
            new Cell(2,7),
            new Cell(3,6)
        };

        int[][] arr = new int[3][];
        arr[0] = new int[2];
        arr[1] = new int[3];
        arr[2] = new int[2];
        arr[1][0] = 100; //给arr中第2个元素中的第1个元素赋值为100

        int[][] as = new int[3][4]; //3行4列
        for(int i=0;i<as.length;i++){
            for(int j=0;j<as[i].length;j++){
                as[i][j] = 100;
            }
        }

    }
}

程序一：

Cell.java //格子类,演示构造方法

package oo.day02;

public class Cell {
    int row;        //声明行
    int col;        //声明列
    Cell(){            //构造方法，默认值
        this(0,0);
    }
    Cell(int n){    //构造方法，默认值
        this(n,n);
    }
    Cell(int row,int col){    //构造方法，取值，赋值
        this.row = row;
        this.col = col;
    }

    void drop(){            //下落一格
        row++;                //行号增1
    }
    void drop(int n){        // 下降n格
        row+=n;
    }
    void moveLeft() { // 左移1格
        col--;
    }
    void moveLeft(int n){    // 左移n格
        col -=n;
    }
    String getCellInfo(){
        return row+","+col;
    }
}

CellTest.java   //格子类的测试类

package oo.day02;
//格子类的测试类
public class CellTest {
    public static void main(String[] args) {
        //构建方法
        Cell c1 = new Cell(); //0,0
        System.out.println("---0------0-----");
        printWall(c1);
        Cell c2 = new Cell(2); //2,2
        System.out.println("---2------2-----");
        printWall(c2);
        Cell c3 = new Cell(2,5); //2,5
        System.out.println("---2------5-----");
        printWall(c3);

        /*
        方法一(不建议使用)：
        Cell c = new Cell();
        c.row = 2;
        c.col = 6;
        c.drop();
        c.drop(3);
        c.moveLeft();
        c.moveLeft(3);
        */
    }

    //打墙+打格
    public static void printWall(Cell cc){
        for(int i=0;i<20;i++){ //行
            for(int j=0;j<10;j++){ //列
                if(i==cc.row && j==cc.col){ //行列匹配
                    System.out.print("* ");
                }else{
                    System.out.print("- ");
                }
            }
            System.out.println(); //换行
        }
    }
}

程序二：

Cell.java  

package oo.day02;
//格子类
public class Cell {
    int row; // 行号
    int col; // 列号
    Cell(){
        this(0,0);
    }
    Cell(int n){
        this(n,n);
    }
    Cell(int row,int col){
        this.row = row;
        this.col = col;
    }

    String getCellInfo() { // 获取格子的行号和列号
        return row + "," + col; // 返回行列号
    }
}

T.java

package oo.day02;
//T型
public class T {
    Cell[] cells; //格子数组
    T(){
        this(0,0);
    }
    T(int row,int col){
        this.cells = new Cell[4]; //创建格子数组对象
        this.cells[0] = new Cell(row,col); //创建格子对象
        this.cells[1] = new Cell(row,col+1);
        this.cells[2] = new Cell(row,col+2);
        this.cells[3] = new Cell(row+1,col+1);
    }

    void drop(){ //下落
        for(int i=0;i<this.cells.length;i++){
            this.cells[i].row++;
        }
    }
    void moveLeft(){ //左移
        for(int i=0;i<cells.length;i++){
            cells[i].col--;
        }
    }
    void moveRight(){ //右移
        for(int i=0;i<cells.length;i++){
            cells[i].col++;
        }
    }
    void print(){ //输出4个格子的行列号
        for(int i=0;i<this.cells.length;i++){
            String str = this.cells[i].getCellInfo();
            System.out.println(str);
        }
    }
}

J.java

package oo.day02;
//J型
public class J {
    Cell[] cells;
    J(){
        this(0,0);
    }
    J(int row,int col){
        cells = new Cell[4];
        cells[0] = new Cell(row,col);
        cells[1] = new Cell(row,col+1);
        cells[2] = new Cell(row,col+2);
        cells[3] = new Cell(row+1,col+2);
    }

    void drop(){ //下落
        for(int i=0;i<cells.length;i++){
            cells[i].row++;
        }
    }
    void moveLeft(){ //左移
        for(int i=0;i<cells.length;i++){
            cells[i].col--;
        }
    }
    void moveRight(){ //右移
        for(int i=0;i<cells.length;i++){
            cells[i].col++;
        }
    }
    void print(){ //输出4个格子的行列号
        for(int i=0;i<cells.length;i++){
            String str = cells[i].getCellInfo();
            System.out.println(str);
        }
    }
}

TJTest.java

package oo.day02;
//T类与J类的测试类
public class TJTest {
    public static void main(String[] args) {
        T t = new T(2,5);
        t.print();

        t.drop();
        System.out.println("下落后:");
        t.print();

        t.moveLeft();
        System.out.println("左移后:");
        t.print();
    }
}
时间： 2024-10-22 09:00:28

Unit02-OOP-对象和类，数组（下）的相关文章

JavaScript 浅析数组对象与类数组对象

数组(Array对象) 数组的操作 创建数组方法 添加与修改数组元素 删除数组元素 使用数组元素 遍历数组元素 多维数组 数组相关的函数 concat() join() pop() push() shift() unshift() reverse() sort() slice() splice() 类数组对象 定义 举例 对比数组 转换 间接 直接 数组(Array对象) 数组就是一组数据. 在JavaScript中没有数组这种数据类型.数组时对象创建的. 键(下标): 用于区分数组中不同数值的

[Effective JavaScript 笔记]第58条：区分数组对象和类数组对象

示例 设想有两个不同类的API.第一个是位向量:有序的位集合 var bits=new BitVector(); bits.enable(4); bits.enable([1,3,8,17]); bits.bitAt(4);//1 bits.bitAt(8);//1 bits.bitAt(9);//0 enable方法被重载了,可以传入一个索引或索引的数组.第二个类的API是字符串集合:无序的字符串集合 var set=new StringSet(); set.add('Hamlet'); se

JavaScript中的类数组对象

在javascript中,对象与数组都是这门语言的原生规范中的基本数据类型,处于并列的位置. 一般来说,如果我们有一个对象obj和一个数组a: obj["attr1"];    //取obj对象的attr1属性 a[1];   //取数组a中的第二个元素 但是,有些时候,也会将一个对象“伪装”成一个数组来用,我们把这种对象称为“类数组对象”,再此我们可以給它下一个定义,请看如下的代码: var a= {}; var i = 0; for(i=0; i<10 ; i++){ a[i

JS中集合对象(Array、Map、Set)及类数组对象的使用与对比

原文地址 在使用js编程的时候,常常会用到集合对象,集合对象其实是一种泛型,在js中没有明确的规定其内元素的类型,但在强类型语言譬如Java中泛型强制要求指定类型. ES6引入了iterable类型,Array,Map,Set都属于iterable类型,它们可以使用for...of循环来遍历,都内置forEach方法. 数组 遍历 普通遍历 最简单的一种,也是使用频率最高的一种. let arr = ['a', 'b', 'c', 'd', 'e'] for (let i = 0; i < ar

javascript：类数组 -- 对象

在javascript中,对象与数组都是这门语言的原生规范中的基本数据类型,处于并列的位置. 类数组:本质是一个对象,只是这个 对象  的属性有点特殊,模拟出数组的一些特性. 一般来说,如果我们有一个对象obj和一个数组a: obj["attr1"];    //取obj对象的attr1属性 a[1];              //取数组a中的第二个元素 但是,有些时候,也会将一个对象"伪装"成一个数组来用,我们把这种对象称为"类数组对象",再

Javascript 类数组（Array-like）对象

Javascript中的类数组对象(Array-like object)指的是一些看起来像数组但又不是数组的对象.Javascript中的arguments变量.document.getElementsByTagName()返回值就是典型的类数组对象. 类数组特性 类数组对象具有一个length属性且length的值为非负整数. 类数组对象不具有数组对象的方法.例如:push. pop等方法. 类数组对象可以像数组一样遍历,但不支持数组对象的方法. function test1() { for(

类数组及其转换

什么是类数组 ? 宽泛点讲,一个具有length属性的对象就是类数组,但类数组顾名思义它只是像数组但又不是数组,所以它往往不具备数组自带的方法,如forEach(), push(), shift()等等 ? 在JavaScript的世界里有许许多多的类数组,如NodeList, HTMLCollection, NameNodeMap, DOMTokenList,还有函数中的arguments...它们都是具有length的对象 类数组转化成数组 ? 上面说了类数组只是长得像数组但不具备好些数组所

jQuery类数组

1.什么是类数组 jQuery对象封装的多个DOM对象 类:指的是类似 具备自己特有的操作方法 2.类数组的操作 length属性 each(fn)遍历类数组,fn用来处理DOM对象.在fn中this表示正在被遍历的那个DOM对象.fn函数可以添加一个参数i用于表示正在被遍历的DOM对象的下标(从0开始) eq(index):将下标等于index的DOM对象取出来 get():返回一个DOM对象组成的数组 index(obj):返回DOM或jQuery对象在类数组中的下标. <ul> <

JavaScript之jQuery-6 jQuery 类数组的操作

一.jQuery 类数组的操作 类数组简介 - jQuery 对象封装的多个 DOM 对象 - 类: 指的是类似 - 具备自己特有的操作方法 类数组的操作 - length属性 - each(fn)遍历类数组,fn用来处理DOM对象.在fn中this表示正在被遍历的那个DOM对象.fn函数正在被遍历的那个DOM对象.fn函数可以添加一个参数i用于表示正在被遍历的DOM对象的下标(从0开始) - eq(index):将下标等于index的DOM对象取出来 - get(): 返回一个DOM对象组成的

arguments类数组对象

------------   ECMAScript中的所有参数传递的都是值,不可能通过引用传递参数. --------------------------JS函数没有真正意义上的重载. 在函数内部有两个特殊的对象 : arguments和this. 当函数被调用时,传入的参数将保存在arguments类数组对象中,通过arguments可以访问所有该函数被调用时传递给它的参数列表. arguments并不是一个真正的数组,而是一个“类似数组(array-like)”的对象,因为arguments