Java基础-06.总结二维数组,面向对象

  1. 云栖社区>
  2. 博客>
  3. 正文

Java基础-06.总结二维数组,面向对象

奋斗蒙 2016-12-05 17:36:00 浏览1150
展开阅读全文


1:二维数组(理解)

(1)元素是一维数组的数组。
(2)格式:
A:数据类型[][] 数组名 = new 数据类型[m][n];
B:数据类型[][] 数组名 = new 数据类型[m][];
C:数据类型[][] 数组名 = new 数据类型[][]{{...},{...},{...}};
D:数据类型[][] 数组名 = {{...},{...},{...}};

/*
二维数组:就是元素为一维数组的一个数组。

格式1:
数据类型[][] 数组名 = new 数据类型[m][n];

m:表示这个二维数组有多少个一维数组。
n:表示每一个一维数组的元素有多少个。

注意:
A:以下格式也可以表示二维数组
a:数据类型 数组名[][] = new 数据类型[m][n];
b:数据类型[] 数组名[] = new 数据类型[m][n];
B:注意下面定义的区别
int x;
int y;
int x,y;

int[] x;
int[] y[];

int[] x,y[];
*/
class Array2Demo {
public static void main(String[] args) {
//定义一个二维数组
int[][] arr = new int[3][2];
//定义了一个二维数组arr
//这个二维数组有3个一维数组的元素
//每一个一维数组有2个元素
//输出二维数组名称
System.out.println(arr); //地址值[[I@175078b
//输出二维数组的第一个元素一维数组的名称
System.out.println(arr[0]); //地址值[I@42552c
System.out.println(arr[1]); //地址值[I@e5bbd6
System.out.println(arr[2]); //地址值[I@8ee016
//输出二维数组的元素
System.out.println(arr[0][0]); //0
System.out.println(arr[0][1]); //0
}
}


/*
格式2:
数据类型[][] 数组名 = new 数据类型[m][];

m:表示这个二维数组有多少个一维数组。
列数没有给出,可以动态的给。这一次是一个变化的列数。
*/
class Array2Demo2 {
public static void main(String[] args) {
//定义数组
int[][] arr = new int[3][];

System.out.println(arr);//[[I@175078b
System.out.println(arr[0]); //null
System.out.println(arr[1]); //null
System.out.println(arr[2]); //null

//动态的为每一个一维数组分配空间
arr[0] = new int[2];
arr[1] = new int[3];
arr[2] = new int[1];

System.out.println(arr[0]); //[I@42552c
System.out.println(arr[1]); //[I@e5bbd6
System.out.println(arr[2]); //[I@8ee016

System.out.println(arr[0][0]); //0
System.out.println(arr[0][1]); //0
//ArrayIndexOutOfBoundsException
//System.out.println(arr[0][2]); //错误

arr[1][0] = 100;
arr[1][2] = 200;
}
}
/*
格式3:
基本格式:
数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};
简化版格式:
数据类型[][] 数组名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};

举例:
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
int[][] arr = {{1,2,3},{4,5},{6}};
*/
class Array2Demo3 {
public static void main(String[] args) {
//定义数组
int[][] arr = {{1,2,3},{4,5},{6}};

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]); //1
System.out.println(arr[1][0]); //4
System.out.println(arr[2][0]); //6

System.out.println(arr[0][1]); //2
System.out.println(arr[1][1]); //5
//越界
System.out.println(arr[2][1]); //错误
}
}


(3)案例(掌握):
A:二维数组的遍历
B:二维数组的求和
C:杨辉三角形


/*  练习题(1)
需求:二维数组遍历

外循环控制的是二维数组的长度,其实就是一维数组的个数。
内循环控制的是一维数组的长度。
*/
class Array2Test {
public static void main(String[] args) {
//定义一个二维数组
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};

//请问谁代表{1,2,3}
//arr[0]就是第一个数组
//arr[0] = {1,2,3};
for(int x=0; x<arr[0].length; x++) {
System.out.println(arr[0][x]);
}
System.out.println("--------------");

for(int x=0; x<arr[1].length; x++) {
System.out.println(arr[1][x]);
}
System.out.println("--------------");

for(int x=0; x<arr[2].length; x++) {
System.out.println(arr[2][x]);
}
System.out.println("--------------");

//用循环改进
for(int x=0; x<3; x++) {
for(int y=0; y<arr[x].length; y++) {
System.out.print(arr[x][y]+" ");
}
System.out.println();
}
System.out.println("--------------");

//这个时候,注意了,3是我们根据上面的代码得出来的
//但是,它不能针对任何的数组都可以这样
//所以,我们应该想办法改进
//其实,外面的这个循环的长度就是二维数组的长度

for(int x=0; x<arr.length; x++) {
for(int y=0; y<arr[x].length; y++) {
System.out.print(arr[x][y]+" ");
}
System.out.println();
}
System.out.println("--------------");

//用方法改进
//调用方法
printArray2(arr);
System.out.println("--------------");

//我们再来一个列数是变化的
int[][] arr2 = {{1,2,3},{4,5},{6}};
printArray2(arr2);
}

/*
需求:遍历二维数组
两个明确:
返回值类型:void
参数列表:int[][] arr
*/
public static void printArray2(int[][] arr) {
for(int x=0; x<arr.length; x++) {
for(int y=0; y<arr[x].length; y++) {
System.out.print(arr[x][y]+" ");
}
System.out.println();
}
}
}
/*  练习题(2)
公司年销售额求和
某公司按照季度和月份统计的数据如下:单位(万元)
第一季度:22,66,44
第二季度:77,33,88
第三季度:25,45,65
第四季度:11,66,99

分析:
A:把题目的数据用二维数组来表示
int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
B:如何求和呢?
求和其实就是获取到每一个元素,然后累加即可。
C:定义一个求和变量sum,初始化值是0。
D:通过遍历就可以得到每一个二维数组的元素。
E:把元素累加即可。
F:最后输出sum,就是结果。
*/
class Array2Test2 {
public static void main(String[] args) {
//把题目的数据用二维数组来表示
int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};

//定义一个求和变量sum,初始化值是0。
int sum = 0;

//通过遍历就可以得到每一个二维数组的元素。
for(int x=0; x<arr.length; x++) {
for(int y=0; y<arr[x].length; y++) {
//把元素累加即可。
sum += arr[x][y];
}
}

//最后输出sum,就是结果。
System.out.println("一年的销售额为:"+sum+"万元");
}
}
/*  练习题(3)


需求:打印杨辉三角形(行数可以键盘录入)

1
1 1
1 2 1
1 3 3 1
1 4 6 4 1 
1 5 10 10 5 1


分析:看这种图像的规律
A:任何一行的第一列和最后一列都是1
B:从第三行开始,每一个数据是它上一行的前一列和它上一行的本列之和。

步骤:
A:首先定义一个二维数组。行数如果是n,我们把列数也先定义为n。
 这个n的数据来自于键盘录入。
B:给这个二维数组任何一行的第一列和最后一列赋值为1
C:按照规律给其他元素赋值
从第三行开始,每一个数据是它上一行的前一列和它上一行的本列之和。
D:遍历这个二维数组。
*/
import java.util.Scanner;


class Array2Test3 {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);

//这个n的数据来自于键盘录入。
System.out.println("请输入一个数据:");
int n = sc.nextInt();

//定义二维数组
int[][] arr = new int[n][n];

//给这个二维数组任何一行的第一列和最后一列赋值为1
for(int x=0; x<arr.length; x++) {
arr[x][0] = 1; //任何一行第1列
arr[x][x] = 1; //任何一行的最后1列
}

//按照规律给其他元素赋值
//从第三行开始,每一个数据是它上一行的前一列和它上一行的本列之和。
for(int x=2; x<arr.length; x++) {
//这里如果y<=x是有个小问题的,就是最后一列的问题
//所以这里要减去1
//并且y也应该从1开始,因为第一列也是有值了
for(int y=1; y<=x-1; y++) {
//每一个数据是它上一行的前一列和它上一行的本列之和。
arr[x][y] = arr[x-1][y-1] + arr[x-1][y];
}
}

//遍历这个二维数组。
/*
for(int x=0; x<arr.length; x++) {
for(int y=0; y<arr[x].length; y++) {
System.out.print(arr[x][y]+"\t");
}
System.out.println();
}
*/
//这个时候,要注意了,内循环的变化必须和曾经讲过的九九乘法表类似
for(int x=0; x<arr.length; x++) {
for(int y=0; y<=x; y++) {
System.out.print(arr[x][y]+"\t");
}
System.out.println();
}
}
}


2:两个思考题(理解)
(1)Java中的参数传递问题
Java中只有值传递。

基本类型:形式参数的改变不影响实际参数
引用类型:形式参数的改变直接影响实际参数
(2)数据加密问题
综合的小案例。

/*
思考题1:看程序写结果,然后分析为什么是这个样子的。并画图讲解。最后总结Java中参数传递规律。

Java中的参数传递问题:
基本类型:形式参数的改变对实际参数没有影响。
引用类型:形式参数的改变直接影响实际参数。
*/
class ArgsDemo {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println("a:"+a+",b:"+b); //a:10,b:20
change(a,b);
System.out.println("a:"+a+",b:"+b); //???a:10,b:20


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


public static void change(int a,int b) { //a=10,b=20
System.out.println("a:"+a+",b:"+b); //a:10,b:20
a = b; //a=20
b = a + b; //b=40
System.out.println("a:"+a+",b:"+b); //a:20,b:40
}


public static void change(int[] arr) { //arr={1,2,3,4,5};
for(int x=0; x<arr.length; x++) {
if(arr[x]%2==0) {
arr[x]*=2;
}
}
//arr={1,4,3,8,5};
}
}
/*
某个公司采用公用电话传递数据信息,数据是小于8位的整数,为了确保安全,
在传递过程中需要加密,加密规则如下:
首先将数据倒序,然后将每位数字都加上5,再用和除以10的余数代替该数字,
最后将第一位和最后一位数字交换。 请任意给定一个小于8位的整数,
然后,把加密后的结果在控制台打印出来。 

题目要求:
A:数据是小于8位的整数
定义一个int类型的数据
int number = 123456;
B:加密规则
a:首先将数据倒序
结果 654321
b:然后将每位数字都加上5,再用和除以10的余数代替该数字
结果 109876
c:最后将第一位和最后一位数字交换
结果 609871
C:把加密后的结果输出在控制台

通过简单的分析,我们知道如果我们有办法把这个数据变成数组就好了。
不是直接写成这个样子的:
int[] arr = {1,2,3,4,5,6};

如何把数据转成数组呢?
A:定义一个数据
int number = 123456;
B:定义一个数组,这个时候问题就来了,数组的长度是多少呢?
int[] arr = new int[8]; //不可能超过8
在赋值的时候,我用一个变量记录索引的变化。
定义一个索引值是0
int index = 0;
C:获取每一个数据
int ge = number%10
int shi = number/10%10
int bai = number/10/10%10

arr[index] = ge;
index++;
arr[index] = shi;
index++;
arr[index] = bai;
...
*/
class JiaMiDemo {
public static void main(String[] args) {
//定义一个数据
int number = 123456;

//定义一个数组
int[] arr = new int[8];

//把数据中每一位上的数据获取到后存储到数组中
/*
int index = 0;
arr[index] = number%10; //arr[0]=6;
index++;
arr[index] = number/10%10; //arr[1]=5;
index++;
arr[index] = mumber/10/10%10; //arr[2]=4;
*/

//通过观察这个代码,我们发现应该是可以通过循环改进的
int index = 0;

while(number > 0) { //number=123456,number=12345,number=1234,number=123,number=12,number=1,number=0
arr[index] = number%10; //arr[0]=6,arr[1]=5,arr[2]=4,arr[3]=3,arr[4]=2,arr[5]=1
index++;//index=1,index=2,index=3,index=4,index=5,index=6
number/=10;//number=12345,number=1234,number=123,number=12,number=1,number=0
}

//然后将每位数字都加上5,再用和除以10的余数代替该数字
for(int x=0; x<index; x++) {
arr[x] += 5;
arr[x] %= 10;
}

//最后将第一位和最后一位数字交换
int temp = arr[0];
arr[0] = arr[index-1];
arr[index-1] = temp;

//输出数据
for(int x=0; x<index; x++) {
System.out.print(arr[x]);
}
System.out.println();
}
}


/*
把刚才的代码改进一下:
A:把数据改进为键盘录入
B:把代码改进为方法实现


另一个数据的测试:
number:1234567
第一步:7654321
第二步:2109876
第三步:6109872

知识点:
变量
数据类型
运算符
键盘录入
语句
方法
数组
*/
import java.util.Scanner;


class JiaMiDemo2 {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);

//请输入一个数据
System.out.println("请输入一个数据(小于8位):");
int number = sc.nextInt();

//写功能实现把number进行加密
//调用
String result = jiaMi(number);
System.out.println("加密后的结果是:"+result);
}

/*
需求:写一个功能,把数据number实现加密。
两个明确:
返回值类型:String 做一个字符串的拼接。
参数列表:int number
*/
public static String jiaMi(int number) {
//定义数组
int[] arr = new int[8];

//定义索引
int index = 0;

//把number中的数据想办法放到数组中
while(number > 0) {
arr[index] = number%10;
index++;
number /= 10;
}

//把每个数据加5,然后对10取得余数
for(int x=0; x<index; x++) {
arr[x] += 5;
arr[x] %= 10;
}

//把第一位和最后一位交换
int temp = arr[0];
arr[0] = arr[index-1];
arr[index-1] = temp;

//把数组的元素拼接成一个字符串返回
//定义一个空内容字符串
String s = "";

for(int x=0; x<index; x++) {
s += arr[x];
}

return s;
}
}


3:面向对象(掌握)
(1)面向对象
面向对象是基于面向过程的编程思想
(2)面向对象的思想特点
A:是一种更符合我们思考习惯的思想
B:把复杂的事情简单化
C:让我们从执行者变成了指挥者

举例:
买电脑
洗衣服
做饭
...
万事万物皆对象
(3)把大象装进冰箱(理解)
A:面向过程实现
B:面向对象实现

注意:如何让我们的操作更符合面向对象思想呢?
A:有哪些类
B:每个类有哪些成员
C:类与类的关系
(4)类与对象
A:现实生活中存在的东西,叫事物
属性 事物的基本描述 (外在特征)姓名,年龄,性别
行为 事物的功能     (能做什么事情)吃饭,睡觉,学习


B:Java语言中最基本的单位是类。所以,我们要用类来体现事物


C:类
成员变量 事物属性
成员方法 事物行为
D:类:
是一组相关的属性和行为的集合。是一个抽象的概念。
class类名(……)
 对象:
是该类事物的具体存在,是一个具体的实例。(对象)
 
 举例:
学生:类
班长:对象
(5)类的定义及使用
A:类的定义
成员变量 定义格式和以前一样,就是位置不同,在类中,方法外。
成员方法 定义格式和以前一样,就是去掉了static。
B:使用类的内容
a:创建对象? 格式
类名 对象名 =  new 类名();
b:如何使用成员变量和成员方法呢
对象名.成员变量
对象名.成员方法()
(6)案例:
A:学生类的定义和使用
B:手机类的定义和使用
(7)内存图
A:一个对象的内存图
B:二个对象的内存图
C:三个对象的内存图
(8)Java程序的开发,设计和特征
A:开发:就是不断的创建对象,通过对象调用功能
B:设计:就是管理和维护对象间的关系
C:特征
a:封装
b:继承
c:多态


1:面向对象思想
面向对象:是基于面向过程的编程思想。

面向过程:强调的是每一个功能的步骤
面向对象:强调的是对象,然后由对象去调用功能

2:面向对象的思想特点
A:是一种更符合我们思想习惯的思想
B:可以将复杂的事情简单化
C:将我们从执行者变成了指挥者

举例:
买电脑:
面向过程:我的了解电脑--了解我自己的需求--找对应的参数信息--去中关村买电脑--讨价还价--买回电脑
面向对象:我知道我要买电脑 -- 班长去给我买 -- 班长就买回来了
洗衣服:
面向过程:把衣服脱下--找一个盆--放点洗衣粉--加点水--把衣服扔进去--搓一搓--清洗衣服--拧干--晾起来
面向对象:把衣服脱下--打开全自动洗衣机--扔进去--一键即可--晾起来
吃饭:
面向过程:去超市买菜--摘菜--洗菜--切菜--炒菜--盛起来--吃
面向对象:上饭店吃饭,你--服务员(点菜)--厨师(做菜)--服务员(端菜)--吃

家常事物,买洗衣机和去饭店太不划算了,所以,找个对象。
但是,你不跟我好好学习,你将来4000,你对象8000。

3:把大象装进冰箱
面向过程:
动作有哪些呢?
A:打开冰箱门
B:装进大象
C:关闭冰箱门

代码体现;
class Demo {
public static void main(String[] args) {
/*
System.out.println("打开冰箱门");
//打开冰箱门的东西,我现在仅仅是为了演示,就写了一个输出语句
//其实,它可能需要做很多操作。
//这个时候代码就比较多一些了
//假设我要多次打开冰箱门,
//代码一多,每次都写一遍,麻烦不
//我们就应该用方法改进

System.out.println("装进大象");
System.out.println("关闭冰箱门");
*/

//写了方法以后,调用就改变了
open();
in();
close();
}

public static void open() {
System.out.println("打开冰箱门");
}

public static void in() {
System.out.println("装进大象");
}

public static void close() {
System.out.println("关闭冰箱门");
}
}

面向对象:
我们怎么才能更符合面向对象思想呢?
A:有哪些类呢?
B:每个类有哪些东西呢?
C:类与类直接的关系是什么呢?

把大象装进冰箱的分析? (如何分析有哪些类呢?UML。名词提取法。)
A:有哪些类呢?
大象
冰箱
Demo
B:每个类有哪些东西呢?
大象:
进去
冰箱:
开门
关门
Demo:
main方法
C:类与类直接的关系是什么呢?
Demo中使用大象和冰箱类的功能。

代码体现:
class 大象 {
public static void in() {
System.out.println("装进大象");
}
}

class 冰箱 {
public static void open() {
System.out.println("打开冰箱门");
}

public static void close() {
System.out.println("关闭冰箱门");
}
}

class Demo {
public static void main(String[] args) {
冰箱调用开门
大象调用进去
冰箱调用关门
}
}

4:开发,设计,特征
面向对象开发
就是不断的创建对象,使用对象,指挥对象做事情。

面向对象设计
其实就是在管理和维护对象之间的关系。


面向对象特征
封装(encapsulation)
继承(inheritance)
多态(polymorphism)


/*  手机类::


手机事物:
属性:品牌,价格,颜色...
行为:打电话,发短信,玩游戏...

手机类:
成员变量:品牌,价格,颜色
成员方法:打电话,发短信,玩游戏
*/
class Phone {
//品牌
String brand;
//价格
int price;
//颜色
String color;

//打电话的方法
public void call(String name) {
System.out.println("给"+name+"打电话");
}

//发短信的方法
public void sendMessage() {
System.out.println("群发短信");
}

//玩游戏的方法
public void playGame() {
System.out.println("玩游戏");
}
}


/*
手机类的测试
*/
class Phone {
//品牌
String brand;
//价格
int price;
//颜色
String color;

//打电话的方法
public void call(String name) {
System.out.println("给"+name+"打电话");
}

//发短信的方法
public void sendMessage() {
System.out.println("群发短信");
}

//玩游戏的方法
public void playGame() {
System.out.println("玩游戏");
}
}


class PhoneDemo {
public static void main(String[] args) {
//创建手机对象
//类名 对象名 = new 类名();
Phone p = new Phone();

//直接输出成员变量值
System.out.println(p.brand+"---"+p.price+"---"+p.color);

//给成员变量赋值
p.brand = "诺基亚";
p.price = 100;
p.color = "灰色";
//再次输出
System.out.println(p.brand+"---"+p.price+"---"+p.color);

//调用方法
p.call("林青霞");
p.sendMessage();
p.playGame();
}
}


     
/*   学生类::


在一个java文件中写两个类:一个基本的类,一个测试类。
注意:文件名称和测试类名称一致。

如何使用呢?
创建对象使用。

如何创建对象呢?
格式:类名 对象名 = new 类名();

如何使用成员变量呢?
对象名.变量名
如何使用成员方法呢?
对象名.方法名(...)
*/
//这是学生类
class Student {
//姓名
String name; //null
//年龄
int age; //0
//地址
String address; //null

//学习
public void study() {
System.out.println("学生爱学习");
}

//吃饭
public void eat() {
System.out.println("学习饿了,要吃饭");
}

//睡觉
public void sleep() {
System.out.println("学习累了,要睡觉");
}
}


//这是学生测试类
class StudentDemo {
public static void main(String[] args) {
//类名 对象名 = new 类名();
Student s = new Student();

//输出成员变量值
//System.out.println(s.name);
//System.out.println(s.age);
//System.out.println(s.address);
//改进写法
System.out.println(s.name+"---"+s.age+"---"+s.address);


//给成员变量赋值
s.name = "林青霞";
s.age = 27;
s.address = "北京";
//赋值后的输出
System.out.println(s.name+"---"+s.age+"---"+s.address);

//调用方法
s.study();
s.eat();
s.sleep();
}
}


/*
事物:
属性 事物的信息描述
行为 事物的功能

类:
成员变量 事物的属性
成员方法 事物的行为

定义一个类,其实就是定义该类的成员变量和成员方法。

案例:我们来完成一个学生类的定义。

学生事物:
属性:姓名,年龄,地址...
行为:学习,吃饭,睡觉...

把事物要转换为对应的类:

学生类:
成员变量:姓名,年龄,地址...
成员方法:学习,吃饭,睡觉...

成员变量:和以前变量的定义是一样的格式,但是位置不同,在类中方法外。
成员方法:和以前的方法定义是一样的格式,但是今天把static先去掉。

首先我们应该定义一个类,然后完成类的成员。
*/
//这是我的学生类
class Student {
//定义变量
//姓名
String name;
//年龄
int age;
//地址
String address;

//定义方法
//学习的方法
public void study() {
System.out.println("学生爱学习");
}

//吃饭的方法
public void eat() {
System.out.println("学习饿了,要吃饭");
}

//睡觉的方法
public void sleep() {
System.out.println("学习累了,要睡觉");
}

}


网友评论

登录后评论
0/500
评论
奋斗蒙
+ 关注