java语言学习（2）

标签：arr java 语言 int 学习 数组 new 方法 public

写在前面的话

注：部分笔记没有保存，丢失了，这部分大多数是关于java的几种控制语句，和c语言的结构和写法大体一致，所以不必太担心。但是给自己提了个醒，一定要有保存的习惯，下面写一些零碎的知识点

continue的细节分析和说明

• 这里也有label这个功能

return

使用方法：表示跳出所在的方法，在讲解方法的时候，会详细的介绍。注意：如果写在return写在main方法，退出程序。

内容补充（java中的一种输入方式）

import java.util.Scanner;
public class Test{
    public ststic void main(STring[] args){
        Scanner scanner = new Scanner(System.in);
        int a = scanner.nextInt();
        System.out.println(a);
    }
}

第六章

数组的介绍

数组：可以存放多个同一类型的数据，数组也是一种数据类型，是引用类型。即：数组就是一组数据

    double[] hens = {3,5,1,3.4,2}
    //double[]表示double类型的数组，
    //数组名 hens
    //括号里的值表示数组的值

数组的长度：数组名.length

int len = hens.length;

数组的使用

• 动态初始化1

• 动态初始化2

• 静态初始化

数组的定义：数据类型 数组名[] = new 数据类型[大小]

• 动态初始化1

  int a[] = new int[5]
  //创建了一个数组，名字a，存放5个int

• 动态初始化2

  //先声明数组
  int a[];
  //创建数组
  a = new int[10];

• 静态初始化 int a[] ={1,2,3,4,5,6}; //如果知道数据有多少值，具体值

数组的使用注意事项和细节

• 数组是多个相同类型数据的组合，实现对这些数据的统一管理

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

• 数组创建后，如果没有赋值，有默认值，int，short，byte，long 为0 float，double为0.0，char \u0000,boolean fales,String null

• 使用数组的步骤

  • 声明数组并且开辟空间

  • 给数组各个元素赋值

  • 使用数组

• 数组的下标是从0开始的

• 下标越界会报错

• 数组属于引用类型，数组型数据是对象

数组赋值的机制

基本数据类型赋值，赋值方式为值拷贝

n2的变化会影响到n1的值

    int n1 = 10;
    int n2 = n1;
    n2 = 80;
    System.out.println("n1=" + n1);
    System.out.println("n2=" + n2);

数组在默认情况下是引用传递，赋的值是地址。赋值方式为引用传递，传递的是一个地址

    int arr1 = {1,2,3};
    int arr2 = arr1;
    //这里arr2的变化会影响的arr1
    arr2[0] = 10;
    System.out,println("arr1 =" + arr1[0]);

值传递和 引用传递的区别

jvm里面的内存分为，栈，堆，方法区

注：数组的之间的赋值，是将地址的传递，所以赋值后，他们两个指向的是同一块区域

数组的拷贝

    int arr1[] = {10,20,30};
    int arr2[] = new int[arr1.length];
    for(int i = 0;i<arr1.length;i++){
        arr2[i] = arr1[i];
    }

数组添加

• 实现动态给数组添加元素效果，实现对数组扩容

  • 原始数组使用静态分配 int[] arr ={1,2,3}

  • 增加的元素，直接放在数组的最后

  • 用户可以通过如下的方法来决定是否继续添加

思路分析

• 定义初始数组 int arr[] = {1,2,3}

• 定义一个新的数组 int arrNew = new int [arr.length+1];

• 遍历arr数组，依次将arr的元素拷贝到arrNew数组

• 将4 赋给arrNew[arrNew.length - 1] = 4

• 让arr 指向 arrNew; arr = arrNew;

• 那么原来的arr数组就被销毁

    int arr[] = {1,2,3};
    int arrNew[] = new int[arr.length +1];
    for(int i= 0;i<arr.length;i++){
        arrNew[i] = arr[i];
    }
    arrNew[arrNew.length -1] = 4;
    arr = arrNew；

排序（冒泡排序）

排序的介绍

• 排序是将多个数据，依指定的顺序精选排列的过程

排序的分类

• 内部排序

  • 指将需要处理的所有数据都加载到内部存储器中精选排序。包括（交换式排序法，选择式排序法，插入式排序法）

• 外部排序

  • 数据量过大，无法全部加载到内存中，需要借助外部内存进行排序。包括（合并排序法和直接合并排序法）

冒泡排序法

基本思想：通过对待排序序列从前到后，依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就像水底的气泡一样逐渐向上冒

    public class work_1{
        public static void main(String[] args){
            int arr[] = {33,22,77,5,6,20};
            int tem = 0;
            for(int i = 0;i<arr.length-1;i++){
                for(int j = 0;j<arr.length -1-i;j++){
                    if(arr[j] > arr[j+1]){
                        tem = arr[j];
                        arr[j] = arr[j+1];
                        arr[j+1] = tem;
                    }
                }
            }
            for(int i = 0;i<arr.length-1;i++){
                System.out.println(arr[i]);
            }
        }
    }

二维数组

• 动态初始化1

  • 类型[][] 数组名 = new 类型[大小][大小]

  • 比如:int a[][] = new int[2][3];

   //遍历数组代码
    int a[][] = new int[2[3];
    for(int i = 0;i<arr.length;i++){
        for(int j = 0;j<arr[i].length;j++{
            System.out,print(arr[i][j]);    
        }
        System.out.print("\n");
    }

二维数组的内存存储

• 动态初始化2

  • 先声明：类型 数组名[][]

  • 再定义（开辟空间）数组名 = new 类型[][]

  • 赋值（有默认）

  • 使用

• 动态初始化，列数不确定

• 

个人理解：为什么能实现这个功能，因为二维数组里放的是一维数组的地址

    public class work_1{
        public static void main(String[] args){
            int arr[][] = new int[3][];
            for(int i = 0;i<arr.length;i++){
                arr[i] = new int[i+1];
                for(int j = 0;j<arr[i].length;j++)
                    arr[i][j] = i;
            }
            for(int i = 0;i<arr.length;i++){
                for(int j = 0;j<arr[i].length;j++){
                    System.out.print(arr[i][j] + " ");
                }
                System.out.print("\n");
            }
        }
    }

   int arr[][] = new int[3][]

这行代码：创建二维数组，一共有3个一维数组，但每一个一维数组还没有开空间

• 静态初始化

  • 比如： int arr[][] ={{1,1,1},{8,8,9},{100}};

二维数组使用细节和注意事项

• 一维数组的声明方式有

  • int[] x

  • int x[]

• 二维数组的声明方式有

  • int[][] y

  • int[] y[]

  • int y[][]

• 二维数组实际上是由多个一维数组组成的，他的各个一维数组的长度可以相同，也可以不相同

第七章

面向对象编程

• 类与对象

• 成员方法

• 成员方法传参机制

• overload

• 可变参数

• 作用域

• 构造器

• this

类与对象（oop编程）

用单独的变量解决，数组解决时不利于数据的管理和效率低，所以会用类与对象来解决

对象中包含属性和行为

我们可以通过类创建对象，

当对象创建后，就成了一个具体的对象

一个类的对象可以很多很多

创建对象时的不同说法

• 创建一个对象

• 实例化一个对象

• 吧类实例化…

面对对象方式解决养猫问题

    public class work_1{
        public static void main(String args){
            Cat cat1 = new Cat();
            //使用oop面向对象
            //实例化一只猫
            //new Cat() 创建一只猫
            //Cat cat1 = new Cat();
            //把创建的猫赋给cat1
            //这里的cat1 是对象名(对象引用)
            cat1.name = "小白";
            cat1.age = 3;
            cat1.color = "白色";
            //cat1 就是一个对象
            Cat cat2 = new Cat();
            cat2.name = "小黄";
            cat.age = 10;
            cat.color = "橘色";
            System.out.println("第一只猫" + cat1.name + "" + cat1.age + "" + cat1.color); 
            System.out.println("第二只猫" + cat2.name + "" + cat2.age + "" + cat2.color);     
        }
    }
    
    //定义一个猫类
    class Cat{
        //属性
        String name;
        int age;
        String color;
    }

• 类是一个抽象的，概念的，代表一类事物，比如人类，猫类，即它是数据类型

• 对象是具体化的，实际的，代表一个具体事物，即实例

• 类是对象的一个模板，对象是类的一个个体，对应一个实例

对象在内存中的存在形式

属性（成员变量）

• 从概念或叫法上看，成员变量 = 属性 = field （即 成员变量是用来表示属性的）

• 属性是类的一个组成部分，一般是基于数据类型，也可是引用类型（对象，数组）

属性的注意事项和细节说明

• 属性的应以语法同变量，示例：访问修饰符 属性类型 属性名；

• 访问修饰符有四种 public，proctected,默认，private

• 属性的定义类型可以是任意类型，包含基本数据类型和引用类型

• 属性如果不赋值，有默认值，规则和数组一样

创建对象

• 先声明，再创建

  • Cat cat;//声明对象cat

  • cat = new Cat() //创建

• 直接创建

  • Cat cat = new Cat();

类与对象的内存分配机制

    Person p1 = new Person();
    p1.age = 10;
    p1.name = "小明";
    Person p2 = p1;
    //把 p1 赋给了 p2
    //让 p2 指向了 p1
    System.oyt.println(p2.age);

• 栈：一般存放基本数据类型（局部变量）

• 堆：一般存放对象（数组等）

• 方法区：常量池（常量，字符串），类加载信息

• 示意图

java创建对象的流程简单分析

Person p1 =new Person();

p.name = “jack”;

p.age = 10;

• 先加载类信息（只会加载一次）

• 在堆中分配空间，进行默认初始化

• 把地址赋给p,p就指向对象了

• 进行指定初始化

成员方法

基本介绍：除了一些属性外，还会有一些行为。成员方法也简称为方法

成员方法的定义

public 返回数据类型 方法名（形参列表）{

//方法体

//语句

//return 返回值

}

• 成员方法入门

  • 添加speak 成员方法，输入我是好人

  • 添加cal01 成员方法，计算1加到1000的结果

  • 添加cal02 成员方法，该方法可以接收一个数，计算1+…+n的结构

  • 添加getSum成员方法，可以计算两个数的和

    //方法写好后，不去调用，不会执行
    //先创建对象，然后调用方法
    
    public class work_1{
        public static void main(String[] args){
            Person p1 = new person();
            p1.speak();//调用方法
        }     
    }
    
    class Person{
        String name;
        int age;
        //public 表示方法是公开的
        //void 表示方法没有返回值
        //speak() speak是方法名，()形参列表
        //{}方法体，可以写我们要执行的代码
        public void speak(){
            System.out.println("我是一个好人")
        }
    }

方法的调用机制

方法调用小结

• 当程序执行到方法，就会开辟一个独立的空间（栈空间）

• 当方法执行完毕，或者执行到return语句时，就会返回

• 返回到调用方法的地方

• 返回后，继续执行方法后面的代码

• 当main方法（栈）执行完毕后，整个程序就会退出

为什么需要成员方法

• 提高了代码的复用性

• 可以将实现的细节封装起来，然后供其他用户来调用即可。

注意事项和使用细节

• 返回数据类型

  • 一个方法最多有一个返回值，当有需求返回多个值时，可以返回一个数组

  • 返回类型可以为任意类型，包含基本类型或引用类型（数组，对象）

  • 如果方法有要求返回数据类型，这方法体中最后的执行语句必须为return值，而且要求返回值类型必须和return的值类型一致或兼容

  • 如果方法是void，这方法体中可以没有return语句，或者只写return

  • 方法名：遵循驼峰名命名法，最好见名知意。

• 形参列表

  • 一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开

  • 参数类型可以为任意类型，包含基本数据类型或引用数据类型

  • 调用带参数的方法时，一定对应着参数列表传入相同类型或者兼容类型的参数

• 方法调用

  • 同一类的方法调用：直接调用即可

  • 跨类中的方法调用A类调用B类方法：需要通过对象名调用。

  • 特别说明：跨类的方法调用和方法的访问修饰符相关，先暂时这么提一下，后面我们讲到访问修饰符时，还要再细说

目前类里已经包含属性（成员变量），成员方法。类里还包含其他东西，在以后学

成员方法传参机制

• 基本数据类型，传递的是值（值拷贝），形参的任何改变不影响实参

• 引用类型传递的是地址，可以通过形参影响实参

易错知识

    public class work_1{
        public static void main(){
            Person p = new Person();
            p.age = 10;
            p.name = "hehe"；
            System.out.print(p.age);
            //10
        }
    }
    
    class Person{
        int age;
        String neme;
    }
    
    class B{
        public void text(Person p){
            p = null;
        }
    }

克隆一个对象

    class clone{
        public dog n(dog a){
            return a;
        }//错误的
        public dog n1(dog a){
            dog b = new dog();
            b.age = a.age;
            b.name = a.name;
            return b;
        }//正确
    }

写在最后的话：这两天情绪起伏很大，有时很亢奋，有时又很低落。这情绪的起伏是个人难以控制的，甚至是难以言状的，不可名的事其实也就是情愫化名的喜欢。
但无论情绪如何变化，对于想学的渴望是没有减少的。

诸位加油！

标签：arr,java,语言,int,学习,数组,new,方法,public
From： https://blog.csdn.net/memorycx/article/details/144066621