数组类 java_Java学习---数组的定义和类的使用

一、学习目的

通过今天的学习来掌握数组的定义方式和基本使用，感受与C语言数组中的异同，以及初步认识类与对象的概念，如何创建一个对象，类里面如何定义变量和方法和理解创建对象的内存表现。

二、数组的定义相关

1. 数组的两种定义方式(静态和动态)

//引用类型：除char short int float long double byte以外都是引用类型

//数组一但被定义 大小就确定了 无法更改

//静态

int[] score = {1,2,3};

String[] names = {"jack","marry"};

//动态 内容动态添加

float[] height = new float[5];

height[0] = 180.0f;

height[1] = 170f;

2. 数组定义之后在内存中的表现形式

表现形式

3. 数组的基本使用

Random r = new Random();

int num = r.nextInt(100);

//尽量不要扩大变量的作用域

int[] count = new int[10];

for (int i = 0;i <10;i++){

count[i] = r.nextInt(100);

}

4. 遍历数组的3种方式

for循环，关注元素是第几个

foreach快速循环，不关注元素是第几个

Arrays.toString(数组名),主要用于测试

//数组的遍历

//数组输出方式1 关注第几个

for (int i = 0;i < 10;i++){

System.out.print(count[i]+" ");

}

System.out.print("\n");

//数组输出方式2 快速循环 不关注第几个

for (int temp:count

) {

System.out.print(temp+" ");

}

System.out.print("\n");

//数组输出方式3 用来测试

System.out.println(Arrays.toString(count));

System.out.print("\n");

5. 猜数游戏(Java实现)

主程序代码：

class GuessNumber{

public static void main(String[] args){

//定义一个数组

int[] originalArray = new int[4];

//保存用户输入的猜测数字

int[] guessArray = new int[4];

//产生4个随机数

Random random = new Random();

for (int i = 0;i < 4;i++){

//产生1个随机数

int temp = random.nextInt(10);

//判断是否存在

boolean result = contains(originalArray,temp);

if (result){

//确保i对应的位置能够得到一个不重复的数字

i--;

}else{

originalArray[i] = temp;

}

}

//排序

Arrays.sort(originalArray);

System.out.println(Arrays.toString(originalArray));

//定义一个Scanner对象

Scanner scanner = new Scanner(System.in);

//开始游戏

while (true){

int countA = 0;

int countB = 0;

System.out.print("请输入猜测的数字：");

for (int i = 0;i < 4;i++){

guessArray[i] = scanner.nextInt();

}

//判断用户输入

//1.判断是否存在 2.位置是否相同

for (int i = 0;i <4;i++){

boolean result = contains(guessArray,originalArray[i]);

if (result){

//数字存在

//判断位置是否相同

int index = indexOf(guessArray,originalArray[i]);

if (index == i){

//数字位置都相同

countA++;

}else{

countB++;

}

}

}

if (countA == 4){

System.out.println("Congratulations!!");

break;

}else{

System.out.println(countA+"A"+countB+"B");

}

}

}

在一个数组里面查找某个值的索引值：

/**

* 在一个数组里面查找某个值的索引值

* @param var 数组

* @param obj 查找的对象

* @return 索引值

*/

public static int indexOf(int[] var,int obj){

for (int i = 0;i < var.length;i++){

if (var[i] == obj){

return i;

}

}

return -1;

}

自己写一个方法判断一个数组是否包含某个值:

//自己写一个方法判断一个数组是否包含某个值

public static boolean contains(int[] var,int obj){

for (int i = 0;i < var.length;i++){

if (var[i] == obj){

//重复了

return true;

}

}

return false;

}

}

三、类的使用

Java  OOP:object oriented programming面向对象编程

1. 类和对象的概念

类：java里面除了8大基本数据类型之外 都是对象,是抽象的，不实际存在的，用来描述同一类事物(具有共同的属性 或者方法)

一般来说，类是由数据成员和函数成员封装而成

对象：具体的 实际存在的 某一个类的实例化，且对象都是new出来的，可以完成具体的事情；同一个类可以有多个对象

2. 类的定义

定义一个类 通常情况下一个文件对应一个类

修饰符：public static final

修饰符 class 类名{

这个类的一些属性：成员变量

这个类的功能：方法

}

class Person{

//成员变量 通常定义在类的最上方

//default:

public String name;

public int age;

public float score;

private String password;

public char choice;

//方法的定义 public static final private

public void test(){

System.out.println("没有返回值 没有参数的返回值");

}

}

3.对象的创建

对象一旦创建 属性变量有初始值

char ' '    int long short byte 0

float double 0.0

boolean false

引用数据类型：对象类型的变量 = null

/*

创建Person类的一个对象

使用.访问成员变量

*/

Person xw = new Person();

Person zs = new Person();

/*

同一个类可以创建多个对象

每个对象的内存空间都是独立的(对象之间没有任何关系)

xw和zs除了都是同一个类创建的之外 没有任何关系

对xw属性的操作 不会影响zs

*/

//给这个对象对应的属性赋值

//方法区->堆->栈

xw.name = "小王";

xw.age = 20;

xw.score = 86.5f;

System.out.println(xw.name);

System.out.println(xw.age);

System.out.println(xw.score);

4. 创建的对象的内存表现

image.png

5. 成员方法的声明和访问以及使用

方法的使用:

调用谁(那个对象)的方法

在类里面可以直接调用自己的方法

在外部必须通过对象来调用

//方法的定义 public static final private

public void test(){

System.out.println("没有返回值 没有参数的返回值");

}

public void test2(){

//在自己的类里面可以调用这个类里面的所有资源

//this.test();

test();

}

//没有返回值 接受一个参数

public void test3(String name){

}

//有返回值 接受一个参数

public int test4(String name){

return 0;

}

//有多个参数 每个参数用逗号隔开

public int test5(String name){

return 0;

}

//可变参数 相当于 数组

public int test6(int ... counts){

int sum = 0;

for (int i = 0;i < counts.length;i++){

sum += counts[i];

}

return sum;

}

//调用test6

Person lisi = new Person();

lisi.test();

//匿名对象 ->作为一个参数传递

int result = lisi.test6(new int[]{1, 2, 3, 4, 5});

System.out.println(result);

6. Java语言三大特点

封装：

把私有的东西封装起来 不让外部使用

需要给外部使用 就暴露出来

访问权限：public private protected

public:公共的 内部可以用，外部也可以用

private:私有的 只能自己使用 外部无法访问 子类无法继承

protected:受保护的 外部(同一个包里面)可以访问

继承:

是指一个对象直接使用另一个对象的属性和方法

多态:

一个对外接口，多个内在实现方法

四、心得体会

通过这次的学习，对Java类与对象的概念有了更深层次的理解，也从内存管理的方式上了解其储存方式，总而言之，收获满满，但仍需努力！