首页 > 编程语言 >java数组、面向对象的引入

java数组、面向对象的引入

时间：2023-08-26 10:05:55浏览次数：35  
标签：arr java int System 面向对象 数组 println public out

package com.momo.demo;

public class Main {

public static void main(String[] args) {

int[] arr = new int[3];

System.out.println(arr);

System.out.println(arr[0]);

System.out.println(arr[1]);

System.out.println(arr[2]);

arr[0] = 55; arr[2] = 66; System.out.println(arr); System.out.println(arr[0]); System.out.println(arr[1]); System.out.println(arr[2]); int[] arr2 = new int[3]; System.out.println(arr2); System.out.println(arr2[0]); System.out.println(arr2[1]); System.out.println(arr2[2]); //2个变量指向堆中同一个区域 int[] arr3 = arr; System.out.println(arr3); System.out.println(arr3[0]); System.out.println(arr3[1]); System.out.println(arr3[2]); System.out.println("----------------"); arr3[0] = 6666; arr3[1] = 444; System.out.println(arr3[0]); System.out.println(arr3[1]); System.out.println(arr3[2]); System.out.println("------------"); System.out.println(arr[0]); System.out.println(arr[1]); System.out.println(arr[2]); }

}

1，数组的静态初始化

-格式：

数据类型[] 数组名 = new 数据类型[]{元素1，元素2，...}

int[] arr = new int[]{12,3,4}

-简化：

数据类型[] 数组名 = {元素1，元素2，...}

int[] arr = {12,3,4}

package com.momo.demo;

public class Demo1 {

public static void main(String[] args) {

// int[] arr = new int[3]{12,3,4};java: 同时使用维表达式和初始化创建数组是非法的

// int[] arr = new int[]{12,3,4};

int[] arr = {12,3,4}; System.out.println(arr); System.out.println(arr[0]); System.out.println(arr[1]); }

}

2，数组常见的2个问题

-空指针异常

数组已经不在指向堆内存了，还去访问堆内存中的元素

-索引越界异常

访问了不存在的索引

-要求：以后把自己遇到的所有异常都记录下来并分析

出现的原因，现象，解决方式

package com.momo.demo;

public class Demo2 {

public static void main(String[] args) {

int[] arr = {2,3,4};

System.out.println(arr[0]);

System.out.println(arr[1]);

System.out.println(arr[2]);

//ArrayIndexOutOfBoundsException 索引越界异常

// System.out.println(arr[3]);

arr = null; System.out.println(arr); //System.out.println(arr[0]);NullPointerException 空指针异常 }

}

3，数组的常见操作

-数组遍历：依次输出数组中每一个元素

package com.momo.demo;

public class Demo3 {

public static void main(String[] args) {

int[] arr = {1,2,3,4,5};

/System.out.println(arr[0]);System.out.println(arr[1]);System.out.println(arr[2]);System.out.println(arr[3]);System.out.println(arr[4]);/

//数组中有个属性length，可以获取数组长度 /* for (int i = 0; i < 5; i++) { System.out.println(arr[i]); }*/ /* for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); }*/ System.out.println("---------------------"); int[] arr2 = {12,22,43,54,75}; /* for (int i = 0; i < arr2.length; i++) { System.out.println(arr2[i]); }*/ //如果有很多数组要遍历，只是数组名变化了，说明了这个代码是一个完成特定功能的代码，应该用方法来封装 printArray(arr); System.out.println("----------------"); printArray(arr2); } /* * 遍历数组的方法 * 返回值类型： * void * 参数列表： * 要遍历的数组 * */

/* public static void printArray(int[] arr){

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

System.out.println(arr[i]);

}

}*/

//带格式

public static void printArray(int[] arr){

System.out.print("[");

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

if(i==arr.length-1){

System.out.println(arr[i]+"]");

}else{

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

}

}

}

}

-获取最值

package com.momo.demo;

/*

  • 思路：
  • 先拿任意一个作为参照，（一般第一个）假装是最大的
  • 依次和后面的所有元素比较
  • 大的留下继续比较
  • 小的直接走开
  • 最后留下的就是最大的
  • */

public class Demo4 {

public static void main(String[] args) {

int[] arr = {12,4,11,67,2,879,22,34,234545,2232,3,23,3435,67,989,6654};

/int max = arr[0];for (int i = 1; i < arr.length; i++) {if(arr[i]>max){max = arr[i];}}/

int max = getMax(arr);

System.out.println(max);

}

/*

  • 获取最大值的方法
  • 返回值类型： int
  • 参数列表：int[] arr
  • */

public static int getMax(int[] arr){

int max = arr[0];

for (int i = 1; i < arr.length; i++) {

if(arr[i]>max){

max = arr[i];

}

}

return max;

}

}

-元素逆序

package com.momo.demo;

/*

  • 第一个和最后一个交换位置 arr[0] , arr[arr.length-1-0]
  • 第二个和倒数第二个交换 arr[1] , arr[arr.length-1-1]
  • ...
  • 交换到中间位置 arr.length/2
  • */

public class Demo5 {

public static void main(String[] args) {

int[] arr = {1,2,3,4,5,6};

System.out.println("逆序前：");

printArray(arr);

reverse(arr);

System.out.println("逆序后：");

printArray(arr);

}

/* public static void reverse(int[] arr){

for (int i = 0; i < arr.length/2; i++) {

int temp = arr[i];

arr[i] = arr[arr.length-1-i];

arr[arr.length-1-i] = temp;

}

}*/

public static void reverse(int[] arr){

for (int i=0,j=arr.length-1;i

int temp = arr[i];

arr[i] = arr[j];

arr[j] = temp;

}

}

public static void printArray(int[] arr){

System.out.print("[");

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

if(i==arr.length-1){

System.out.println(arr[i]+"]");

}else{

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

}

}

}

}

-数组元素查找(查找指定元素第一次出现的索引)

注意：不存在的时候返回一个负数 一般返回-1即可

-根据索引获取元素

注意：索引越界

-冒泡排序

-选择排序

-二分查找

一，二维数组

1，元素是一维数组的数组(一条烟)

2，格式

-数据类型[][] 数组名 = new 数据类型[x][y]；

-数据类型[] 数组名[] = new 数据类型[x][y]；

-数据类型 数组名[][] = new 数据类型[x][y]；

x表示二维数组中有多少个一维数组

y表示每一个一位数组中的元素个数

int[][] arr = new int[3][2];

package com.momo.demo;

public class Demo6 {

public static void main(String[] args) {

int[][] arr = new int[3][2];

System.out.println(arr);

System.out.println(arr[0]);

System.out.println(arr[1]);

System.out.println(arr[2]);

System.out.println(arr[0][0]); System.out.println(arr[0][1]); int[] a; int[] b[]; int[] x,y[]; x = new int[2]; System.out.println(x); y = new int[2][3]; System.out.println(y); }

}

-数据类型[][] 数组名 = new 数据类型[x][];

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

package com.momo.demo;

public class Demo7 {

public static void main(String[] args) {

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

System.out.println(arr);

/* System.out.println(arr[0]); System.out.println(arr[1]); System.out.println(arr[2]); System.out.println(arr[0][0]); System.out.println(arr[0][1]);*/ arr[0] = new int[3]; arr[1] = new int[2]; arr[2] = new int[55]; System.out.println(arr[0]); System.out.println(arr[1]); System.out.println(arr[2]); System.out.println(arr[0][0]); System.out.println(arr[0][1]); }

}

-数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2,...},{元素,...},...};

int[][] arr = new int[][]{{1},{2,3,4},{3,4}}

简化：

数据类型[][] 数组名 = {{元素1,元素2,...},{元素,...},...};

int[][] arr = {{1},{2,3,4},{3,4}}

package com.momo.demo;

public class Demo8 {

public static void main(String[] args) {

int[][] arr = {{1},{2,3,4},{3,4}};

System.out.println(arr);

System.out.println(arr[0]);

System.out.println(arr[1]);

System.out.println(arr[2]);

System.out.println(arr[0][0]); //System.out.println(arr[0][1]); }

}

3，常见操作

-遍历：依次输出二维数组中每一个一维数组中的每一个元素

格式：[[1],[2,3,4],[3,4]]

package com.momo.demo;

public class Demo9 {

public static void main(String[] args) {

int[][] arr = {{1},{2,3,4},{3,4}};

print2Array(arr);

}

public static void print2Array(int[][] arr){ System.out.print("["); for (int i = 0; i < arr.length; i++) { if(i==arr.length-1){ System.out.print("["); for (int j = 0; j < arr[i].length; j++) { if(j==arr[i].length-1){ System.out.print(arr[i][j]+"]"); }else{ System.out.print(arr[i][j]+","); } } System.out.println("]"); }else{ System.out.print("["); for (int j = 0; j < arr[i].length; j++) { if(j==arr[i].length-1){ System.out.print(arr[i][j]+"]"); }else{ System.out.print(arr[i][j]+","); } } System.out.print(","); } } }

}

-二维数组求和

-通过键盘输入行数，打印杨辉三角

1

1 1

1 2 1

1 3 3 1

1 4 6 4 1

1 5 10 10 5 1

....

package com.momo.demo;

import java.util.Scanner;

/*

  • 分析：
  • 每一行的第一个和最后一个都是1
  • 从第三行开始，除了第一个和最后一个之外，其余的值都是它上一行前一列和上一行本列值之和

  • 是由多行多列组成的，看成是一个二维数组，先定义一个二维数组
  • 行数是键盘输入的l，我们先把列数也看成l
  • int[][] arr = new int[l][l];
  • 给每一行的第一个和最后一个赋值1
  • 在按照第二个规律给其他列赋值

  • 最后输出的时候按照九九乘法表的方式输出
  • */

public class Demo10 {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

System.out.println("输入行数：");

int l = sc.nextInt();

int[][] arr = new int[l][l]; for (int i = 0; i < arr.length; i++) { arr[i][0] = 1; arr[i][i] = 1; } for (int i = 2; i < arr.length; i++) { for (int j = 1; j < arr[i].length-1; j++) { arr[i][j] = arr[i-1][j-1]+arr[i-1][j]; } } for (int i = 0; i < arr.length; i++) { for (int j = 0; j <= i; j++) { System.out.print(arr[i][j]+"\t"); } System.out.println(); }

}

}

package com.momo.demo;

/*

  • 参数传递问题：
  • 基本类型：形参的改变不影响实际参数
  • 引用类型：形参的改变直接影响实际参数
  • */

public class Demo11 {

public static void main(String[] args) {

int a = 5;

int b = 6;

System.out.println("a="+a+",b="+b);//5,6

change(a,b);

System.out.println("a="+a+",b="+b);//5,6

System.out.println("--------------------");

int[] arr = {1,2,3,4,5,6}; System.out.println(arr[3]);//4 change(arr); System.out.println(arr[3]);//8

}

public static void change(int[] arr) {

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

if(arr[i]%2==0){

arr[i] *= 2;

}

}

System.out.println(arr[3]);//8

}

public static void change(int a, int b) {

a = b;

b = a+b;

System.out.println("a="+a+",b="+b);//6,12

}

}

-练习：使用公用电话传递密码(是一个不大于8位的整数)

为了保证安全，在传递的过程中采用加密，规则如下：

先把数据倒序

然后给每位上的数字加5

在用除以10的余数代替该数字

最后把第一位和最后一位数字交换位置

编写代码实现输入任意一个不大于于8位的整数，把加密后的结果输出到

控制台上。

经过简单分析，如果能把键盘输入的整数变成一个数组，其实就没有难度了

二，面向对象思想

1，我们早上讲解数组常见操作的时候，写了多个方法，随着需求越来越多

我们写的方法也就会越来越多，将来要在多个方法中找方法的时候，就变得

困难了。于是我们就要想办法，降低这个困难，通过前面学习，我们知道类中

可以存放方法，所以我们就可以用不同的类来封装不同类型的方法。

把功能类似的方法封装到一个类中(把操作数组的封装到一个类中，把操作字符串的

方法封装到另一个类中，。。。。) 这样以后我们在想操作数组的时候，

我们就不需要找具体的方法了，我们只需要找到那个封装了数组操作的类，

然后调用方法即可操作--这就是面向对象思想的编程方式

-就是把方法进行分类存储，将来就不需要找具体的方法了，只需要找到对应的类

2，面向对象之前有面向过程：

-面向过程：强调的是每一个步骤

我们之前写的代码都是面向过程的做法，我们现有一个需求

然后分析需求，根据分析出来的步骤我们自己一步步实现。每一步都是我们

自己做的，这就是面向过程的具体体现。

代表语言C语言，是面型对象的基础

-面向对象是基于面向过程的

-面向对象：强调的是对象

3，面向对象思想特点

-把复杂的事情简单化了

-从执行者变成了指挥者

4，代码举例

package com.momo.demo;

/*

  • 爸爸给孩子喂奶
  • 面向过程：

冲奶

喝奶

洗奶瓶

  • /

public class Demo12 {public static void main(String[] args) {/

* 明白：现在只是为了举例子，用一个输出语句表示一个功能，实际一个功能可能需要几百行代码才能完成

* //

System.out.println("冲奶");

System.out.println("喝奶");

System.out.println("洗奶瓶");

//第2次 System.out.println("冲奶"); System.out.println("喝奶"); System.out.println("洗奶瓶"); //第3次 System.out.println("冲奶"); System.out.println("喝奶"); System.out.println("洗奶瓶"); //....*/ /* * 用方法封装一下每一个功能 * */ //1 chongnai(); henai(); xinaiping(); System.out.println("---------------"); //2 chongnai(); henai(); xinaiping();

}

public static void chongnai(){

System.out.println("冲奶");

}

public static void henai(){

System.out.println("喝奶");

}

public static void xinaiping(){

System.out.println("洗奶瓶");

}

}

package com.momo.demo;

/*

  • 爸爸给孩子喂奶
  • 面向对象：

有哪些对象

  • 爸爸类：冲奶，洗奶瓶
  • 孩子类：喝奶
  • 测试类：main
  • */

public class Demo13 {

public static void main(String[] args) {

//1

//调用爸爸的冲奶

//调用孩子的喝奶

//调用爸爸的洗奶瓶

}

}

class Baba{

public static void chongnai(){

System.out.println("冲奶");

}

public static void xinaiping(){

System.out.println("洗奶瓶");

}

}

class Haizi{

public static void henai(){

System.out.println("喝奶");

}

}

5，面向对象开发，设计和特征

-开发：不断的创建对象，使用对象，指挥对象做事强

-设计：就是管理和维护多个对象之间的关系

-特征：

封装

继承

多态

6，类和对象的关系

-编程是为了模拟现实，实现信息化(超市的计费系统)

-如何表示一个现实世界的事务？

属性：描述信息

行为：功能

-学生:

属性：学号，姓名，出生日期，性别...

行为：学习，吃饭，睡觉，谈恋爱...

-我们学习的java基本单位是类， 我们要用类来描述事物

类中有：

成员变量：属性

和之前定义变量的格式一样，只不过现在放到类中方法外

成员方法：行为

和之前定义的方法一样，现在把static去掉即可

-学生类：

成员变量：学号，姓名，出生日期，性别...

成员方法：学习，吃饭，睡觉，谈恋爱...

-类：是一组相关属性和行为的集合，是一个抽象概念

-对象：是该类事物中的具体个体

学生类：

张三

李四

汽车图纸

具体汽车

package com.momo.entity;

/*

  • 学生类
  • */

public class Student {

//成员变量

int id;

String name;

int age;

//成员方法

public void study(){

System.out.println("好好学习，向钱看，向厚赚。");

}

public void sleep(){

System.out.println("学生要休息");

}

}

-创建对象来使用

格式：类名 对象名 = new 类名();

对象名.成员变量

对象名.成员方法(...)

package com.momo.demo;

import com.momo.entity.Student;

public class Demo14 {

public static void main(String[] args) {

Student stu = new Student();

stu.id = 11;

stu.name = "张三";

stu.age = 18;

System.out.println(stu.id);

System.out.println(stu.name);

System.out.println(stu.age);

stu.study(); stu.sleep(); }

}

package com.momo.demo;

/*

  • 假设在一个文件中写多个类，注意文件名和测试类名保持一致
  • */

public class Demo15 {

public static void main(String[] args) {

Phone h1 = new Phone();

System.out.println(h1);

h1.brand = "华为";

h1.color = "中国红";

h1.price = 9999;

System.out.println(h1.brand+","+h1.color+","+h1.price);

h1.call("大大"); h1.send(); System.out.println("---------------"); Phone h2 = new Phone(); System.out.println(h2); h2.brand = "三星"; h2.color = "黑色"; h2.price = 999; System.out.println(h2.brand+","+h2.color+","+h2.price); h2.call("大大"); h2.send(); System.out.println("------------------"); Phone h3 = h1; System.out.println(h3); System.out.println(h3.brand+","+h3.color+","+h3.price); h3.brand = "小米"; h3.color = "黑色"; h3.price = 666; System.out.println(h3.brand+","+h3.color+","+h3.price); System.out.println(h1.brand+","+h1.color+","+h1.price);

}

}

//手机类

class Phone{

String brand;

String color;

int price;

public void call(String name){ System.out.println("给"+name+"打电话"); } public void send(){ System.out.println("发信息"); }

}

7,成员变量和局部变量的区别

-类中位置不同

成员变量：在类中方法外

局部变量：在方法内

-内存位置不同

成员变量：堆

局部变量：栈

-生命周期不同

成员变量：随着对象的创建而存在，随着对象的消失而消失

局部变量：随着方法的调用而存在，随着方法的消失而消失

-初始值不同

成员变量：有默认值

局部变量：没有默认值

-注意：

成员变量名称和局部变量名称可以一样，在方法中使用的时候采用就近原则

package com.momo.demo;

public class Demo16 {

public static void main(String[] args) {

MyVariable m = new MyVariable();

m.show();

System.out.println(m.i);//成员变量

}

}

class MyVariable{

int i = 5;

// int j = 7;

public void show(){

int i = 6;

System.out.println(i);

// System.out.println(j);

}

}

8，参数问题

-一个方法的形式参数是类类型(引用类型)，

实际上调用方法的时候要传递的是该类的具体对象

package com.momo.demo;

public class Demo17 {

public static void main(String[] args) {

//调用Stu中的show方法

/Stu s = new Stu();s.show();/

//调用StuDemo中的method方法

StuDemo sd = new StuDemo();

//int a = 5;

Stu s = new Stu();//地址值

sd.method(s);

}

}

class Stu{

public void show(){

System.out.println("我是学生，我爱学习。。");

}

}

class StuDemo{

/*

* 如果你看到一个方法的形式参数是类类型(引用类型)，实际上调用方法的时候

* 要传递的是该类的具体对象

* */

public void method(Stu s){

//Stu s = new Stu(); 地址值

//只有具体对象才能调用方法

s.show();

}

}

9，匿名对象

-就是没有名字的对象，是对象的简化表示形式

new Stu()

-作用：

可以当作实参传递

当方法仅仅需要调用一次的时候

好处：使用完成之后会立刻变成垃圾

需要调用多次的时候不建议使用

public class Demo17 {

public static void main(String[] args) {

//调用Stu中的show方法

/Stu s = new Stu();s.show();/

//调用StuDemo中的method方法

//StuDemo sd = new StuDemo();

//int a = 5;

/* Stu s = new Stu();//地址值

sd.method(s);*/

//sd.method(new Stu()); Stu s = new Stu(); s.show(); s.show(); s.show(); System.out.println("--------------"); new Stu().show(); new Stu().show(); new Stu().show(); }

}

标签：arr,java,int,System,面向对象,数组,println,public,out
From： https://blog.51cto.com/u_16230968/7240081

相关文章

  • Java猜拳小游戏
    以下代码是一个猜拳小游戏的实现，其中包含了用户输入、随机数生成、逻辑判断和输出结果等功能。首先让用户输入名字，然后每轮循环中用户输入出拳手势，根据输入的数字1、2、3分别代表石头、剪刀、布；同时，系统也会产生一个随机数表示电脑出拳手势。判断用户和电脑的胜负关系，并输出结果。......
  • NumPy学习挑战第十二关-数组操作
    Numpy数组操作Numpy中包含了一些函数用于处理数组，大概可分为以下几类：1、修改数组形状函数 描述reshape 不改变数据的条件下修改形状flat 数组元素迭代器flatten 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组ravel 返回展开数组（1）numpy.reshapenumpy.reshape函数......
  • JavaScript-算术运算符
    概述JavaScript共提供10个算术运算符，用来完成基本的算术运算。加法运算符：x+y减法运算符： x-y乘法运算符： x*y除法运算符：x/y指数运算符：x**y余数运算符：x%y自增运算符：++x 或者 x++自减运算符：--x 或者 x--数值运算符： +x负数值运算符：-x减法、乘法、除法运算法比较单纯......
  • java封装、this关键字
    一，封装1，概述-指的就是把对象的属性细节隐藏起来，外部通过共有的方式来访问。2，好处-提高了代码复用性-提高了安全性3，原则-把不需要对外提供的内容都隐藏起来，根据需求提供对应的共有的访问方式。packagecom.momo.demo;/*我们在使用这个案例的过程中，发现了问题：通过对象给成员变量赋值......
  • Java中的泛型概念
    在Java中，泛型是一种强类型检查机制，它允许我们在编译时期指定类、接口或方法的参数和返回值类型。使用泛型可以实现代码的重用性、类型安全性和提高代码的可读性。下面是关于Java泛型的一些重要概念和用法：泛型类（GenericClass）：通过在类名后面使用尖括号<T>来声明一个泛型类，在类......
  • Java流程控制switch选择结构
    swich选择结构多选择结构还有一个实现方式，就是swichcase语句swichcase语句判断一个变量与一个系列值中某个值是否相等，每个值称为一个分支swich语句中变量类型可以是byte、short、int、char，从Java7SE开始swich支持字符串String类型，同时case标签必须为字符串常量或者字面......
  • 一维数组java练习
    1、打印下列图形*****************************************图形一：publicclassHomeWork8_24{publicstatic......
  • 变量和数据类型java练习
    1.①packagecom.company;publicclassHomeWork8_19{publicstaticvoidmain(String[]args){Stringname="小明";intage=25;intseniority=3;intage1=5;Stringsubject="java";......
  • 选择结构和循环结构java练习
    1、通过键盘输入学生分数并根据成绩定档：0-59分“不及格”，60-69分“及格”，70-79分“中等”，80-89分“良好”，90-100分“优秀”importjava.util.Scanner;publicclassHomeWork8_22{publicstaticvoidmain(String[]args){Scannerscanner=newScanner(System......
  • 数组
    1.容器：将多个数据存储到⼀起，每个数据都称为该容器的⼀个元素2.数组：数组就是⽤于存储数据的固定的容器，保证多个数据的数据类型要⼀致3.数组的特点：  1.数组的长度⼀但确定不能修改  2.创建数组时，会在内存中开辟⼀块连续的空间  3.存取元素的速度快，因为可以......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99