二维数组
1.Demo06
package com.hpe.java;
/**
* 二维数组：数组中的数组
* 创建二维数组：数组类型【】【】 数组名；
* 初始化：
* 1.动态初始化
* 2.静态初始化
*
* @author yang
*
*/
public class Demo06 {
public static void main(String[] args) {
// TODO Auto-generated method stub
//动态初始化
/**
* 第一个中括号：由几行组成，表示有几个一维数组组成
* 第二个中括号：由列组成，表示一个一维数组里面可以保存几个元素
*/
int[][] arr=new int[3][3];
//赋值
arr[0][0]=1;//第一个一维数组的第一个元素值是1；
arr[0][2]=2;
arr[2][1]=9;
arr[1][0]=10;
//arr[3][1]=8;
arr[1][2]=12;
//获取第二个数组第三个元素值
System.out.println(arr[1][2]);
//静态初始化
int[][] arr1=new int[][]{{1,5},{5,9,12},{9,67,9,10}};
//简写
int[][] arr2={{12,89},{90,56}};
System.out.println(arr2[1][0]);
//遍历
//外层控制行
for(int i=0;i<arr1.length;i++){//arr1[0] arr1[1]
//内层控制列
for(int j=0;j<arr1[i].length;j++){
System.out.println(arr1[i][j]+" ");
}
System.out.println();
}
for(int[] i:arr1){
for(int a:i){
System.out.println(a+" ");
}
System.out.println();
}
}
}
2.Demo061
1.在一个酒店中，一共有三层楼，每层有4个房间。
// 101 102 103
// 201 202 203 205
// 301 302
// 楼层:使用数字1,2,3表示
// 房间号:使用101,102,103,104 表示……
// 要求:使用二维数组赋值并遍历输出。
package com.hpe.java;
public class Demo061 {
public static void main(String[] args) {
// TODO Auto-generated method stub
// 在一个酒店中，一共有三层楼，每层有4个房间。
// 101 102 103
// 201 202 203 205
// 301 302
// 楼层:使用数字1,2,3表示
// 房间号:使用101,102,103,104 表示……
// 要求:使用二维数组赋值并遍历输出。
int[][] arr=new int[3][4];
arr[0][0]=101;//第一个一维数组的第一个元素值是1；
arr[0][1]=102;
arr[0][2]=103;
arr[0][3]=104;
arr[1][0]=201;
arr[1][1]=202;
arr[1][2]=203;
arr[1][3]=204;
arr[2][0]=301;
arr[2][1]=302;
arr[2][2]=303;
arr[2][3]=304;
for(int i=0;i<arr.length;i++){//arr1[0] arr1[1]
//内层控制列
for(int j=0;j<arr[i].length;j++){
System.out.println(arr[i][j]+" ");
}
System.out.println();
}
}
}
3.Demo02
package com.hpe.java;
/**
* 什么事方法？
* 方法就是把一堆需要重复执行的代码封装起来，如果程序需要用到这段代码时，我们就可以直接调用方法
* 好处：
* 提高代码重用性。可读性，执行效率
* 把一个方法比喻成一个榨汁机
* 材料：水果
* 产出物：果汁
*
* 程序中的方法：
* 参数（材料）： 进入方法的数据
* 返回值（产出物）：方法根据参数处理后的结果
*
* 定义一个方法？
* 访问修饰符【static】方法返回值类型 方法名（参数类型 参数名）{
* 代码块;
* return 返回值;}
* 访问修饰符:常用的是public格式是固定的
* static:静态的，可加可不加
* 方法的返回值类型：方法最终产生的结果是什么类型的
* 方法名：自己定义的名字
* 参数类型:进行方法的数据是啥类型的
* 代码块：自己封装的逻辑代码
* return:(1).把方法处理的结果返回给调用者（2）。结束当前方法
* 返回值：方法最终结果
*
* 一个方法里面不能定义方法。但是可以调用别的方法
*
* @author yang
*
*/
public class Demo02 {
//一个静态方法只能调用静态方法或静态变量
public static void main(String[] args) {
// TODO Auto-generated method stub
//调用方法
//定义变量接收方法给我们返回的值
//注意：变量的类型必须和方法的返回值类型一致
int result=sum(10,20);//实参，调用方法时，实际传入方法的参数，参数的顺序类型必须和形参的顺序、类型一致
System.out.println("a和b的值"+result);
}
//计算a+b的和
/**
* 返回值类型：int
* 方法名
* 参数：int a int b
*
*/
public static int sum(int a,int b){//形参，用于接受外部传入的数据
System.out.println("方法执行了");
int result=a+b;
return result;
}
}
4.Demo03
package com.hpe.java;
/**
* 无返回值的方法：
* 一个方法去执行一些操作，但是最终没有把处理结果返回给调用方法
* 这种方法就是无返回值的方法
*
* 访问修饰符 void 方法名（参数）{
* 方法体
* return;可写可不写，一般不写
* }
* @author yang
*
*/
public class Demo03 {
public static void main(String[] args) {
// TODO Auto-generated method stub
//直接调用方法
goodgirl();
}
//打印10遍我是好人
//无返回值的方法
public static void goodgirl(){
for(int i=0;i<10;i++){
System.out.println("我是好人");
}
}
}
5.Demo04
package com.hpe.java;
import java.util.Scanner;
public class Demo04 {
public static void main(String[] args) {
// TODO Auto-generated method stub
//定义一个方法，求圆的面积
//方法参数：半径（radius）
//圆周率：Math.PI
Scanner sc=new Scanner(System.in);
System.out.println("请输入圆的面积:");
double r=sc.nextDouble();
System.out.println("圆的面积为");
double result=area(r);
System.out.println(result);
}
public static double area(double r){
double result=Math.PI*r*r;
return result;
}
}
6.Demo042
package com.hpe.java;
public class Demo042 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int sum1=sumThree(1,2,3);
int sum2=sumTwo(1,2);
System.out.println("a+b的和"+sum2);
System.out.println("a+b+c的和"+sum1);
}
//计算a+b的和
public static int sumTwo(int a,int b){
return a+b;
}
//计算a+b+c的和
public static int sumThree(int a,int b,int c){
return a+b+c;
}
}
6.Demo05
package com.hpe.java;
/**
* 对于类似相加的操作，因为我们参数列表不同，所以我定义了多个方法名
* 问题：
* 1.太麻烦
* 2.如果方法名过多，有可能出现调用错误的情况，
*
* 解决方法
* 使用方法重载，我们只需要记住一个方法名就可以了
*
* 方法重载，要求方法名必须相同，参数列表不同
* 什么事参数列表
* 1.参数得个数不同
* 3.参数的类型不同
* 2.参数的类型顺序不同
*
* 注意：方法的重载和返回类型没有关系
* @author yang
*
*/
public class Demo05 {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(sum(1,2));
System.out.println(sum(1,2,3));
}
//方法重载
public static int sum(int a,int b){
return a+b;
}
public static int sum(int a,int b,int c){
return a+b+c;
}
public static int sum(int a,int b,int c,int d){
return a+b+c+d;
}
public static int sum(double a,int b){
return 0;
}
}
7.Demo06
package com.hpe.java;
public class Demo06 {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(calculate(1));
System.out.println(calculate(1,2));
System.out.println(calulate("幸福的 ","你","真好"));
}
public static int calculate(int a){
return a*a;
}
public static int calculate(int a,int b){
return a*b;
}
public static String calulate(String a,String b,String c){
return a+b+c;
}
}
8.Demo061
package com.hpe.java;
public class Demo061 {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(max(1, 2));
System.out.println(max(1.3, 0.6));
System.out.println(max(1.1, 7.2, 6.4));
}
public static int max(int a,int b){
int c=0;
if(a>b){
c=a;
}else{
c=b;
}
return c;
}
public static double max(double a,double b){
double c=0;
if(a>b){
c=a;
}else{
c=b;
}
return c;
}
public static double max(double a,double b,double c){
double d=0;
if(a>b){
if(a>c){
d=a;
}else{d=c;};
}else if(b>a){
if(b>c){
d=b;
}else{d=c;};
}
return d;
}
}
9.Demo01
package com.hpe.java;
import java.util.Arrays;
/**
* 面向过程：C语言
* 当开发一个功能时，看中的是中间的过程，每一个过程中的每一个步骤都需要自己去做
* 面向对象：JAVA
* 当开发一个功能时，不看重具体的过程和步骤，看重的是谁能帮我去完成这件事，找人帮我去做
* @author yang
*
*/
public class Demo01 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] a={10,12,7,9,0,34};
//把数组按照指定的格式来输出[10,12,7,9,0,34]
//面向过程来做
System.out.print("[");
//遍历
for(int i=0;i<a.length;i++){
if(i==a.length-1){
System.out.print(a[i]+"]");
}else{
System.out.print(a[i]+",");
}
}
System.out.println("");
System.out.println("=========================");
//面向对象
//Arrays,把数组格式转成相应的格式进行输出
System.out.println(Arrays.toString(a));
}
}
10.Car类
package com.hpe.java;
public class Car {
/**
* 汽车图纸包含两部分
* 属性：颜色 品牌 价格 长度 宽度
* 行为：跑
*
* 对应到类里面也是两部分：
* 成员变量（属性）：直接在类里面定义
* 成员方法（行为）：把static去掉就是成员方法
*
*
*/
//汽车图纸类
//成员属性
//颜色
String color;
//品牌
String brand;
int price;//价格
int length;//长度
int width;//宽度
//成员方法（行为）
public void run(){
System.out.println("一辆颜色是："+color+",品牌是:"+brand+"价钱是："+price+",长度:"+length+"宽度是："+width+"的小汽车，在大陆上跑");
}
}
Testcar类
package com.hpe.java;
import java.awt.Color;
/**
* 开始造车
* 一个类通常情况是不能直接使用的，就类似于汽车图纸，他是不能够直接跑的，
* 如果想使用这个类，就必须根据类去创建一个真正的对象去使用，
* 就类似于根据汽车图纸去造一辆一辆的小汽车
*
* 怎么去创建一个类的对象？
* 类名 对象名=new 类名（）;
* @author yang
*
* 怎么调用属性呢？
* 对象名.属性名；
* 如果属性没有赋值，将会有一个，默认值
* 怎么调用方法
* 对象名。方法名（）;
*
*/
public class TestCar {
public static void main(String[] args) {
// TODO Auto-generated method stub
//创建一个汽车对象
Car car=new Car();//创建了一个汽车对象
System.out.println(car);
System.out.println(car.color);//null
System.out.println(car.price);//0
//给属性赋值
car.brand="五菱宏光";
car.color="白色";
car.length=10;
car.width=3;
car.price=1000000;
car.run();
//创建第二辆汽车
Car car1=new Car();
car1.brand="玛莎拉蒂";
car1.color="黑色";
car1.length=3;
car1.width=2;
car1.price=300000000;
car1.run();
Car car2=car1;
car2.run();
//创建一个狗类
//属性：名字 年龄 体重 颜色 种类
//方法：吃饭 睡觉 摇尾巴
}
}
