Java学习笔记

public static void main(String[] args) {
        int[] nums; //1.定义(首选)，声明一个数组

        //int nums2[]; //c、c++常用
        nums = new int[10];  //2.创建一个数组

        //3.给数组元素赋值
        nums[0]=1;
        nums[1]=2;
        nums[2]=3;
        nums[3]=4;
        nums[4]=5;
        nums[5]=6;
        nums[6]=7;
        nums[7]=8;
        nums[8]=9;
        nums[9]=10;

        //计算所有元素的和
        int sum=0;
        for (int i = 0; i < nums.length; i++) {
            sum=sum+nums[i];
        }
        System.out.println(sum);
    }

public static void main(String[] args) {
        //静态初始化：创建+赋值
        int[] a={1,2,3,4,5};
        System.out.println(a[0]);

        //动态初始化：包含默认初始化
        int[] b= new int[10];
        b[0]=10;

        System.out.println(b[0]);
    }

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

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

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

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

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

ArrayIndexOutOfBoundsException：数组下标越界异常！

小结：

· 数组是相同数据类型（数据类型可以为任意类型）的有序集合。

· 数组也是对象。数组元素相当于对象的成员变量。

· 数组的长度是确定的，不可变的。如果越界，则报：ArrayIndexOutOfBounds。

public static void main(String[] args) {
        int[] arrays={1,2,3,4,5};

//        //JDK1.5，没有下标
//        for (int array:arrays) {
//            System.out.println(array);
//        }

        
        int[] reverse=reverse(arrays);
        printArray(reverse);
    }
    //反转数组
    public static int[] reverse(int[] arrays){
        int[] result=new int[arrays.length];

        //反转操作
        for(int i=0,j=arrays.length-1;i< arrays.length;i++,j--){
            result[j]=arrays[i];
        }
        return result;
    }
    //打印数组元素
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]+" ");
        }
    }

public static void main(String[] args) {

        //[4][2]
        
        int[][] array={{1,2},{3,4},{5,6},{7,8}};

        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.println(array[i][j]);
            }
        }
    }
    //打印数组元素
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]+" ");
        }
    }

package com.kuang.array;
//冒泡排序
//1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换它们的位置
//2.每一次比较，都会产生出一个最大，或者最小的数字
//3.下一轮则可以少一次排序！
//4.依次循环，直到结束！

import java.util.Arrays;

public class ArrayDemo06 {
    public static void main(String[] args) {
        int[] a={1,2,5,7,9,3,27,33};

        int[] a1=sort1(a);
        System.out.println(Arrays.toString(a1));

        int[] b1=sort2(a);
        System.out.println(Arrays.toString(b1));
    }

    //降序
    public static int[] sort1(int[] array){
        //临时变量
        int temp1=0;

        //外层循环。判断我们这个要走多少次;
        for (int i = 0; i < array.length-1; i++) {

            boolean flag=false;//通过flag标识位减少没意义的比较

            //内层循环，比较判断两个数，如果第一个数比第二个数大，则交换位置
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j+1]>array[j]){
                    temp1=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp1;
                    flag=true;
                }
            }
            if(flag==false){
                break;
            }
        }
        return array;
    }

    //升序
    public static int[] sort2(int[] array){
        //临时变量
        int temp2=0;

        //外层循环。判断我们这个要走多少次;
        for (int i = 0; i < array.length-1; i++) {

            boolean flag=false;//通过flag标识位减少没意义的比较

            //内层循环，比较判断两个数，如果第一个数比第二个数大，则交换位置
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j+1]

java的核心思想就是面向对象编程（Object-Oricented Programming,OOP）

面向对象的本质是：以类的方式组织代码，以对象的组织（封装）数据

· 使用new关键字创建对象

package com.oop.demo02;

//学生类
public class Student {

    //属性：字段
    String name;
    int age;

    //方法
    public void study(){
        System.out.println(this.name+"在学习");
    }
}

package com.oop.demo02;

//一个方法应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        //类：抽象的，实例化
        //类实例化后会返回一个自己的对象！
        //student对象就是一个Student类的具体实例！

        Student student1 = new Student();
        Student student2 = new Student();

        student1.name="小明";
        student1.age=20;

        System.out.println(student1.name);
        System.out.println(student1.age);

        student2.name="小红";
        student2.age=18;

        System.out.println(student2.name);
        System.out.println(student2.age);
    }
}

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

· 类中的构造器称为构造方法，是进行创建对象的时候必须要调用的。并且构造器有以下两个特点： 1.必须和类的名字相同；      2.必须没有返回类型，也不能写void。

· 构造器必须掌握

package com.oop.demo02;

public class Person {
    //一个类即使什么都不写，它也会存在一个方法
    //显示的定义构造器
    String name;

    //实例化初始值
    //无参构造
    //1.使用new关键字，必须要有构造器
    //2，用来初始化值
    public Person(){
    }

    //有参构造：一旦定义了有参构造，无参就必须显示定义
    public Person(String name){
        this.name=name;
    }
}