标签：面向对象编程 -- array2 第三天 System int 数组 array out

今天学习效率有点低看的不多，其中数组知道了定义的规范性 [ ] 是写在数据类型后面的，其中后面的稀疏数组的部分花了点时间理解了下，有图对照着理解还是很快的。还有其中的冒泡排序，以前在C语言的学习中没能很好的理解，在这次的学习中应该算是掌握了，其中主要是内层循环的控制。

后面就是JAVA的核心了面向对象，当初可以说是一窍不通，所以这里的学习还是花了点时间，几个关键点也令我印象深刻 静态方法用static修饰，实例方法则必须要有返回值其中静态方法不能非静态的实例变量和实例方法而实例方法可以访问实例方法和静态成员。 然后类创建的时候回默认创建一个不显的且不带参构造器，如果自己定义了有参构造那么在想调用无参构造的话必须得显示出来也就是手打出来。也温习了下重载：方法名相同参数的类型/个数/顺序不同。 差不多就那么多吧。

数组

1.数组概述

• 数组是相同类型数据的有序集合.

• 数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。

• 其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们.

2.数组的声明创建

• 首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法: dataType[ ] arrayRefVar; //首选的方法 或 dataType arrayRefVar[]; //效果相同，但不是首选方法

• Java语言使用new操作符来创建数组，语法如下: dataType[] arrayRefVar = new dataType[ arraysize];

• 数组的元素是通过索引访问的，数组索引从0开始。

• 获取数组长度: arrays. length

public static void main(String[] args) {
        int[] nums = new int[10]; //1.定义
        int sum = nums.length;
        System.out.println("数组长度为："+sum);
        int j = 1;
        int k = 0;
        for (int i = 0; i < 10; i++) {
            nums [i] =j++;
        }
        for(int sums:nums)
            k += sums;
        System.out.println("总和为:"+k);
    }

 

三种初始化

• 静态初始化

int[] a = {1,2,3};
Man[ ] mans = {new Man(1,1) , new Man(2,2)};

• 动态初始化

int[] a = new int[2];
a[0]=1;
a[1]=2;

• 数组的默认初始化

  • 数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

数组的四个基本特点

• 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。

• 其元素必须是相同类型,不允许出现混合类型。

• 数组中的元素可以是任何数据类型，包括基本类型和引用类型。

• 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的

3.数组使用

• For-Each循环

• 数组作方法入参

• 数组作返回值

public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
​
        //JDK1.5 没有下标
//        for (int array : arrays) {
//            System.out.println(array);
//        }
​
        int[] abc = reverse(arrays);
        printArray(abc);
        
//        for (int array : reverse(arrays)) {
//            System.out.println(array);
//        }
​
    }
​
    //打印数组元素
    public static void printArray(int[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]+"");
        }
    }
​
    //反转数组
    public static int[] reverse(int[] array){
        int[] result = new int[array.length];
        int num = array.length;
        for (int i = 0; i < array.length; i++) {
            num--;
            result[i] = array[num];
        }
        return result;
    }
}

 

4.多维数组

• 多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。

• 二维数组

int a[][] = new int[2][5];

• 解析:以上二维数组a 可以看成一个两行五列的数组。

• 思考:多维数组的使用?

num[1] [0];

 

5.Arrays 类

• 数组的工具类java.util.Arrays

• 由于数组对象本身并没有什么方法可以供我们调用,但API中提供了一个工具类Arrays供我们使用,从而可以对数据对象进行一些基本的操作。

• 查看JDK帮助文档

• Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而"不用"使用对象来调用(注意:是"不用”而不是"不能")

• 具有以下常用功能:

  • 给数组赋值:通过fill方法。

  • 对数组排序:通过sort方法,按升序。

  • 比较数组:通过equals方法比较数组中元素值是否相等

  • 查找数组元素:通过binarySearch方法能对排序好的数组进行二分查找法操作。

public static void main(String[] args) {
        int[] a = {1,2,3,4,555,12,668,1576};
​
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        System.out.println(a);   //[I@1b6d3586
        //打印数组元素
//        System.out.println(Arrays.toString(a));
//        printArray(a);
    }
    public static void printArray(int[] a){
        for (int i = 0; i < a.length; i++) {
            if (i == 0) {
                System.out.print("[");
            }else if(i ==a.length-1){
                System.out.print(a[i]+"]");
            }else
                System.out.print(a[i]+", ");
        }
    }

 

6. 冒泡排序

public static void main(String[] args) {
​
        int[] array= {1,6,5,8,7,9,3,2};
        sort(array);
        System.out.println(Arrays.toString(array));
    }
​
    //冒泡排序
    //比较数组中两个相邻的元素，如果第一个数比第二个数大我们就交换他们的位置
    //每一次比较都会产生一个最大或最小的数字
    //下一轮则可以少一次排序
    //依次排序直到结束
    static int[] sort(int[] array){
    //临时变量
        int temp = 0;
        //外层循环，判断我们要走多少次
        for (int i = 0; i < array.length - 1; i++) {
            //内层循环比较两个数，如果第一个数比第二个数大我们就交换他们的位置
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j+1] < array[j]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
        return array;
    }

7.稀疏数组

• 当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。

• 稀疏数组的处理方式是:

  • 记录数组一共有几行几列，有多少个不同值

  • 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

public static void main(String[] args) {
        //1.创建一个二维数组11*11 0：没有棋子 1：黑棋 2：白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        //输出原始数组
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+" ");
            }
            System.out.println();
        }
        System.out.println("========================");
        //转换为稀疏数组
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array1[i][j]!=0)
                    sum++;
            }
        }

        //创建一个稀疏数组的数组
        int [][] array2 = new int[sum+1][3];

        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;
        
        //遍历二维数组将非0值存放到稀疏数组中
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j]!=0){
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                }
            }
        }

        //输出稀疏数组
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0]+"\t"
            +array2[i][1]+"\t"
            +array2[i][2]+"\t");
        }

        System.out.println("========================");
        System.out.println("还原");
        //还原稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];

        //给其中的元素还原值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }

        //打印
        //输出还原数组
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt+" ");
            }
            System.out.println();
        }
    }

 ===================================================================================================

面向对象编程

1、初识面向对象

• 面向过程思想

  • 步骤清晰简单，第一步做什么，第二步做什么.....

  • 面对过程适合处理一些较为简单的问题

• 面向对象思想

  • 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。

  • 面向对象适合处理复杂的问题，适合处理需要多人协作的问题!

• 对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

• 面向对象编程(Object-Oriented Programming, OOP)

• 面向对象编程的本质就是:以类的方式组织代码，以对象的组织(封装)数据。

• 抽象

• 三大特性

  • 封装

  • 继承

  • 多态

• 从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象

• 从代码运行角度考虑是先有类后有对象。类是对象的模板。

2、方法回顾和加深

• 方法的定义

  • 修饰符返回类型

  • break:跳出switch，结束循环和return的区别

  • 方法名

  • 参数列表

  • 异常抛出

• 方法的调用

  • 静态方法非

  • 静态方法

    • 静态方法不能访问非静态的实例变量和实例方法。实例方法可以访问静态成员和非静态成员。

    • static方法时和类一起加载的，而其他没用static修饰的是类实例化之后才存在的

• 形参和实参

• 值传递和引用传递

• this关键字

3、对象的创建分析

• 类是一种抽象的数据类型,它是对某一类事物整体描述/定义,但是并不能代表某一个具体的事物.

  • 动物、植物、手机、电脑....

  • Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为

• 对象是抽象概念的具体实例

  • 张三就是人的一个具体实例,张三家里的旺财就是狗的一个具体实例。能够体现出

  • 特点,展现出功能的是具体的实例,而不是一个抽象的概念.

4.创建与初始化对象

• 使用new关键字创建对象

• 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。

• 类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点:

  • 1.必须和类的名字相同

  • 2.必须没有返回类型,也不能写void

• 构造器必须要掌握

  • 使用new关键字,本质是在调用构造器

  • 一旦定义了有参构造，无参就必须显示定义

  • alt+insert 快速创建构造器

5.封装

• 该露的露，该藏的藏

  • 我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉;低耦合:仅暴露少量的方法给外部使用。

• 封装（数据的隐藏)

  • 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

• 记住这句话就够了:属性私有,get/set

public class Student {
    private String name;
    private int id;
    private String sex;
​
​
    public String getName(){return name;}
​
    public void setName(String name) {this.name = name;}
​
    public int getId() {return id;}
​
    public void setId(int id){this.id = id;}
​
    public String getSex(){return sex;}
​
    public void setSex(String sex) {this.sex = sex;}
}
​
public static void main(String[] args) {
        Student student = new Student();
        student.setName("Ren");
​
        System.out.println(student.getName());
    }

1. 提高程序的安全性，保护数据

2. 隐藏代码的实现细节

3. 统一接口

4. 系统可维护性增加了

 

6.继承

• 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。

• extends的意思是“扩展”。子类是父类的扩展。

• JAVA中类只有单继承，没有多继承!

• 继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。

• 继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。

• 子类和父类之间,从意义上讲应该具有" is a"的关系.

• object类

• super

• 方法重写

标签：面向对象编程,--,array2,第三天,System,int,数组,array,out
来源： https://www.cnblogs.com/fengyvxxx/p/15786121.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。