Java学习笔记 7-14 数组+面向对象

m0_51364610

已于 2022-07-17 10:05:54 修改

阅读量257

点赞数

文章标签： java 学习

于 2022-07-17 10:04:27 首次发布

本文链接：https://blog.csdn.net/m0_51364610/article/details/125828822

版权

本文详细介绍了Java中的数组，包括定义、声明、优势与局限、动态初始化、存储特点、遍历访问以及顺序查找。此外，还讲解了Java的面向对象特性，如类、对象、构造方法、封装、继承、多态，以及静态属性、静态方法和静态代码块。最后，文章探讨了二维数组及其遍历，并通过实例展示了如何使用杨辉三角形来应用二维数组。

摘要由CSDN通过智能技术生成

Java数组

1. Java 数组的定义

数组：是一种可以用来存储同种数据类型的多个值的容器，数组内的每个元素被称为数组元素，可以通过访问下标来寻找数组元素。

2. Java 数组的声明

声明数组的语法有两种：

数组类型[] 变量名; （较为常用）
数组类型变量名[]；

package com.myh.day0714;  
public class ArrayStateDemo {  
    public static void main(String[] args) {  
        // 1  
        int[] num1;  
  
        // 2  
        int num2[];  
    }  
}

3. 数组的优势与局限

优势：按索引查询元素时速度快；能存储大量数据；按索引遍历数组较为方便。
局限：根据内容查找元素速度慢；数组的大小不能改变；只能存储相同类型的数据；增加、删除元素效率低。

4. 数组的动态初始化

初始化是为数组中的数组元素分配内存空间，并为每个数组元素赋值。

动态初始化：

初始化时只指定数组长度，由系统为数组分配初始值。

格式：数据类型[] 变量名 = new 数据类型[数组长度];

package com.myh.day0714;  
public class ArrayInitDemo {  
    public static void main(String[] args) {  
        int[] num = new int[5];  
    }  
}

5. 数组的存储特点（堆和栈）

栈内存用来存放对象，栈内存用来存放方法中定义的局部变量。

数组被声明后，会在该方法的栈内为其划分一块空间，对数组进行初始化后会在堆中为其划分出相应大小的空间用于存放数组元素，同时会将数组在堆中对象的首地址赋给栈中声明的变量。

6. 数组的遍历访问（普通循环，增强for循环）

普通for循环：通过下标来遍历数组中的元素，遍历时可以读取或修改元素的值。
增强for循环：for-each是JDK1.5新增加的功能，专门用于读取读取数组或集合中所有的元素，不可修改元素的值，不涉及有关索引的操作。

package com.myh.day0714;  
public class ArrayForDemo {  
    public static void main(String[] args) {  
        int[] num = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};  
  
        //普通循环  
        for(int i = 0; i < num.length; ++i) {  
            System.out.print(num[i] + " ");  
        }  
        System.out.println();  
  
        //增强for循环  
        for (int i : num) {  
            System.out.print(i + " ");  
        }  
    }  
}

0 1 2 3 4 5 6 7 8 9 
0 1 2 3 4 5 6 7 8 9

7. 数组元素的顺序查找

顺序查找即遍历数组查找，效率较低，但适用于任意数组。

package com.myh.day0714;  
public class ArrayFindDemo {  

    public static int find(int[] num, int x) {  
        for(int i = 0; i < num.length; ++i) {  
            if(num[i] == x) {  
                return i;  
            }  
        }  
        return -1;  
    }  
  
    public static void main(String[] args) {  
        int[] num = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};  
        int x = 6;  
        int i = find(num, x);  
        if(i >= 0) {  
            System.out.println("元素" + x + "的索引是" + i);  
        } else {  
            System.out.println("数组中没有" + x + "元素");  
        }  
    }  
}

8. Arrays工具类的使用

Arrays工具类是一个专门用来操作数组的工具类，提供了大量静态操作方法方便实际项目开发使使用。下面介绍Arrays工具类中常用的几个方法。

Arrays工具类的常用方法有：

Arrays.toString()：将数组内容用字符串表示
Arrays.equal()：比较两个数组是否相等
Arrays.sort()：对数组进行排序
Arrays.binarySearch()：二分法查找元素（查找前需先排序）

package com.myh.day0714;

import java.util.Arrays;

public class ArraysUtilsTest {
    public static void main(String[] args) {
        int[] num1 = new int[]{2, 3, 5, 7, 9, 4, 6, 0, 8, 1};
        int[] num2 = new int[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

        // Arrays.toString() 将数组内容用字符串表示
        System.out.println(Arrays.toString(num2));

        // Arrays.equal() 比较两个数组是否相等
        boolean equal = Arrays.equals(num1, num2);
        System.out.println(equal);

        // Arrays.sort() 对数组进行排序
        Arrays.sort(num1);
        System.out.println(Arrays.toString(num1));

        // Arrays.binarySearch() 二分法查找元素（查找前需先排序）
        int i = Arrays.binarySearch(num1, 4);
        System.out.println(i);
    }
}

9. 二维数组的介绍

二维数组是一种用来存储一维数组的容器。二元数组中存放的一元数组长度可以不同，但数据类型要一致。可以通过访问下标的方式来寻找某个一维数组中的某个位置的元素。

10. 二维数组的声明与初始化

与一元数组类似，二元数组的声明也有两种：

数组类型[][] 变量名;
数组类型变量名[][]；

package com.myh.day0714;
public class ArrayStateDemo {
    public static void main(String[] args) {
        // 1
        int[][] num1;

        // 2
        int num2[][];
    }
}

二元数组的初始化分为静态初始化和动态初始化。

静态初始化：在初始化时就确定数组的大小和每个位置的元素的值。
动态初始化：与一元数组类似，初始化时只指定数组长度，由系统为数组分配初始值。

package com.myh.day0714;

public class ArrayInitDemo {
    public static void main(String[] args) {
        //动态初始化
        int[][] num1 = new int[5][10];

        //动态初始化
        int[][] num2 = {{0, 1, 2, 3}, {4, 5}, {6, 7, 8}, {9}};
    }
}

11. 二维数组的遍历

与一元数组类似，二元数组的遍历可以使用普通for遍历和增强for遍历。

package com.myh.day0714;
public class TwoDArrayDemo {
    public static void main(String[] args) {
        //二维数组的遍历
        // 1 普通for遍历
        for(int i = 0; i < num.length; ++i) {
            for(int j = 0; j < num[i].length; ++j) {
                System.out.print(num[i][j] + " ");
            }
            System.out.println();
        }
        System.out.println("----------------");
        
        // 2 增强for遍历
        for (int[] ints : num) {
            for (int i : ints) {
                System.out.print(i + " ");
            }
            System.out.println();
        }
    }
}

0 1 2 3 
4 5 
6 7 8 
9 
----------------
0 1 2 3 
4 5 
6 7 8 
9

12. 二维数组的使用

这里使用打印杨辉三角形为例子来展示二维数组的使用。

package com.myh.day0714;
public class TwoDArrayDemo {
    public static void main(String[] args) {
        //二维数组的使用
        //例：打印杨辉三角形
        int[][] ang = new int[9][9];
        for(int i = 0; i < ang.length; ++i) {
            ang[i][0] = ang[i][i] = 1;
            for(int j = 1; j < i; ++j) {
                ang[i][j] = ang[i-1][j-1] + ang[i-1][j];
            }
        }

        for(int i = 0; i < ang.length; ++i) {
            for(int j = 0; j <= i; ++j) {
                System.out.print(ang[i][j] + " ");
            }
            System.out.println();
        }
    }
}

1 
1 1 
1 2 1 
1 3 3 1 
1 4 6 4 1 
1 5 10 10 5 1 
1 6 15 20 15 6 1 
1 7 21 35 35 21 7 1 
1 8 28 56 70 56 28 8 1

java面向对象#

1. 面向对象设计思想

面向对象的基本实现是，从现实世界中客观存在的事物出发来构造软件系统，并在系统的构造中尽可能运用人类的自然思维方式。面向对象更加强调运用人类在日常生活的逻辑思维中经常采用的方法原则，如抽象、分类、继承、聚合、多态等。

2. 面向对象的分析与设计

面向对象分析：目的是获得对应问题的理解，理解的目的是确定系统功能和性能要求。面向对象分析包括五个活动：认定对象，组织对象，对象间的相互作用，定义对象的操作，定义对象的内部信息。
面向对象设计：是设计分析模型和实现相应的源代码。

3. Java与面向对象

Java 是面向对象的编程语言，对象就是面向对象程序设计的核心。对 Java 语言来说，一切皆是对象。把现实世界中的对象抽象地体现在编程世界中，一个对象代表了某个具体的操作。一个个对象最终组成了完整的程序设计，这些对象可以是独立存在的，也可以是从别的对象继承过来的。对象之间通过相互作用传递信息，实现程序开发。

Java的三大核心特征：

封装
继承
多态

4. 类中成员变量的定义与意义

成员变量定义在类中，在整个类中都可以被访问，且随着所在类的对象的建立而建立，随着对象的消失而消失，存在于对象所在的堆内存中，有初始化默认值。

成员变量的定义：

[public|protected|private][static][final] 变量类型变量名;

class Person {
    public String name;
    protected int age;
    private static int sex;
    public final String race = "person"; 
}

成员变量的意义：

成员变量类的一种属性，是事物静态特征的抽象。

5. 构造方法的定义和调用

构造方法是构造类对象时调用的方法，通过调用构造方法可以创建出一个类的实例。
构造方法分为无参构造方法和有参构造方法，无参构造方法没有形参，有参构造方法有形参。

一个类可以有多个构造方法，调用构造方法时系统会根据括号内的参数个数来对应构造方法。如果一个类没有构造方法则系统会给该类自动添加一个无参构造方法。

package com.myh.day0714;

class Person {
    public String name;
    protected int age;
    private static int sex;
    public final String race = "person";

    Person() {}

    Person(String name, int age, int sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
}

public class ClassDemo {
    public static void main(String[] args) {
        Person person1 = new Person();
        Person person2 = new Person("myh", 20, 1);
    }
}

6. 面向对象的封装特性

封装：利用抽象数据类型将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体。数据被保护在抽象数据类型的内部，尽可能地隐藏内部的细节，只保留一些对外接口使之与外部发生联系。用户无需知道对象内部的细节，但可以通过对象对外提供的接口来访问该对象。

package com.myh.day0714;

class Person {
    public String name;
    protected int age;
    private static int sex;
    public final String race = "person";

    Person() {}

    Person(String name, int age, int sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public void setSex(int sex) {
        this.sex = sex;
    }

    public int getSex(int sex) {
        return sex;
    }
}

public class ClassDemo {
    public static void main(String[] args) {
        Person person1 = new Person();
        Person person2 = new Person("myh", 20, 1);

        person1.setSex(0);
    }
}

7. 静态属性、静态方法、静态代码块

静态属性：用static修饰的属性，存放在内存的方法区中，随着类的建立而建立，随着类的销毁而销毁。
静态方法：用static修饰的方法，静态方法只能访问静态属性。
静态代码块：写在类中的方法外用static修饰的代码块，只在加载类时初始化，不能访问普通变量，不能出现在任何方法体内。

package com.myh.day0714;

class Pig {
    static int num = 10;
    int a = 20;
    static void run() {
        System.out.println("静态方法被调用啦！");
    }
    static {
        System.out.println("静态代码块被调用啦！");
        System.out.println(num);
    }

    Pig() {
        System.out.println("对象创建啦！");
    }
}

public class ClassStaticDemo {
    public static void main(String[] args) {
        Pig pig = new Pig();
        pig.run();
    }
}

静态代码块被调用啦！
10
对象创建啦！
静态方法被调用啦！

8. 面向对象的继承特性

继承：就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

子类可以通过super调用父类的构造方法。

子类能够继承父类的所有public和protected成员，但不能继承private成员，只能通过父类提供的公共接口访问。

子类可以重写父类的函数。

package com.myh.day0714;

class Person1 {
    public String name;
    public int age;
    private int sex = 1;

    Person1(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void getAge() {
        System.out.print("这是父类方法");
        System.out.println(age);
    }

    public void getSex() {
        System.out.print("这是父类方法");
        System.out.println(sex);
    }

    public void sayHi() {
        System.out.print("这是父类方法");
        System.out.println("Hi!");
    }
}

class Student extends Person1 {

    Student(String name, int age) {
        super(name, age);
    }

    public void sayHi() {
        System.out.println("Hello!");
    }
}

public class ClassInheritDemo {
    public static void main(String[] args) {
        Student stu = new Student("zhangsan", 5);
        stu.getAge();
        stu.getSex();
        stu.sayHi();
    }
}

这是父类方法5
这是父类方法1
Hello!

9. 面向对象的多态特性

多态：是指允许不同子类型的对象对同一消息作出不同的响应。

package com.myh.day0714;

class Animal {
    public void cry() {
        System.out.println("animal 在叫");
    }
}

class Dog extends Animal {
    @Override
    public void cry() {
        System.out.println("dog 在汪汪叫");
    }
}

class Cat extends Animal {
    @Override
    public void cry() {
        System.out.println("cat 在喵喵叫");
    }
}

public class ClassMulTest {
    public static void main(String[] args) {
        Animal dog = new Dog();
        Animal cat = new Cat();
        dog.cry();
        cat.cry();
    }
}

dog 在汪汪叫
cat 在喵喵叫

10. 抽象方法与抽象类

抽象类：用abstract修饰的类，不能被实例化，但是有构造器便于子类实例化时调用。
抽象方法：用abstract修饰的方法，只有方法的声明，没有方法体。

抽象类的子类必须全部覆写抽象类中的抽象方法，抽象类中可以有实例方法。
abstract不能修饰属性、构造器、私有方法、静态方法、final方法。

package com.myh.day0714;

abstract class Person2 {
    abstract void walk();
    public void run() {
        System.out.println("I'm running.");
    }
}

class Student1 extends Person2 {

    @Override
    void walk() {
        System.out.println("Student is walking.");
    }
}

public class AbstractDemo {
    public static void main(String[] args) {
        Person2 stu = new Student1();
        stu.walk();
        stu.run();
    }
}

Student is walking.
I'm running.

11. 接口的介绍

接口：是一些方法的集合，一系列方法的声明，一个接口只有方法的特征而没有方法的实现，这些方法在不同的地方被不同的类实现。

package com.myh.day0714;

interface InterfaceA {
    public void Method1();
    public void Method2();
}

class InterfaceDemo1 implements InterfaceA {

    @Override
    public void Method1() {
        System.out.println("It's method1");
    }

    @Override
    public void Method2() {
        System.out.println("It's method2");
    }
}

class InterfaceDemo {
    public static void main(String[] args) {
        InterfaceDemo1 in = new InterfaceDemo1();
        in.Method1();
        in.Method2();
    }
}