JZTXT

第一周总结

发布时间 2023-07-01 17:18:09作者: 伐木工熊大

第一天：

今天在电脑上安装了JDK和eclipse，学会了用javac命令和java命令进行编译和运行java

public class HelloWorld{
    public static void main(String[] args){
        System.out.println("HelloWorld");
    }
}

 

 

 

并且自己根据目前所学的知识思考了Java语言和C++的不同之处：

首先Java是以类为主体的，Java的类中的main方法相当于C++中的主函数

其余的操作方式例如for循环，if语句等都和C++相同

例如：

#include<iostream>
using namespace std;
int main()
{    
      int a=100;
      for(int i=0;i<100;i++)
    {
     if(i<a)
        {
           --a;
           cout<<a--<<endl;
         }
    }
}

 

在Java中

public class mihoyo {
     public static void main(String[] args)
     {
         int a=100;
         for(int i=0;i<100;i++)
         {
             if(i<a)
             {
                 --a;
                 System.out.println(a--);
             }
         }
     }
}

 

 

 可看出，虽然是两种不同的语言，但是这两种语言有很多的语法是相通的

第二天:

先是做了教材书上的一些关于选择和循环的习题

例:

打印菱形

import java.util.Scanner;
public class 菱形 {
    public static void main(String[] args)
    {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        for(int i=0;i<n;i++)
        {
            for (int k=0;k<n-1-i;k++)
            {
                System.out.print(" ");
            }
            for(int j=0;j<=2*i;j++)
                {
                System.out.print("*");
                }
            System.out.print("\n");
        }
        for(int i=0;i<n-1;i++)
        {
            for(int k=0;k<=i;k++)
            {
                System.out.print(" ");
            }
            for(int j=0;j<2*(n-i)-3;j++)
            {
            System.out.print("*");
            }
            System.out.print("\n");
        }
        
    }

}

学习了Java中数组的构造方法，Java中数组的构造方法和C++有些不同，Java中的数组首先得声明再分配空间才能初始化

C++：int a[10];

Java:int[] a=new int[10];或者int a[]=new int [10];

还了解了Java中的填充替换Arrays fill(type a[],int x)将a数组的全部元素都替换为x，Arraysfill(type a[],c,d,f)将数组a中c到d号元素都替换为f（不包括d元素）。

Java中数组自带的排列函数Arrays.sort(type a[])从将数组a小到大排列（大写字母在小写字母前面），Arrays.sort(type a[],int b,int c)将b到c号元素进行从小到大排列（不包括c）

import java.util.Arrays;

public class 填充替换 {
    public static void main(String[] args)
    {
        int[] a=new int[]{1,3,4,5,2,6};
        Arrays.fill(a, 3);//替换所有元素
        for(int x:a)
        {
            System.out.print(x+" ");
        }
        System.out.
        println();
        Arrays.fill(a,1,3,2);//替换第1到2号元素（第三号元素不换）
        for(int x:a)
        {
            System.out.print(x+" ");
        }
    }
}

 

使用sort从大到小排列需要使用到Comparator,先在开头导入 import java.util.Comparator;再进行重写注意排列的元素类型是Integer，如果要用int还要改写。

import java.util.Arrays;
import java.util.Comparator;
public class sort排序 {
    static Comparator<Integer> cmp=new Comparator<Integer>() {//重写Compare
        public int compare(Integer a,Integer b)//注意形参是Integer类型
        {
            return b-a;
        }
    };
    public static void main(String[] args)
    {
        Integer[] a={3,2,4,5,7,5,4,7,9,8,0};
        /*int a[]=new int[] {3,2,4,5,7,5,4,7,9,8,0};
        Arrays.sort(a,0,5);//0至4号元素从小到大排列
        for(int x:a)
        {
            System.out.print(x+" ");
        }
        
        System.out.println();
        */
         /*Arrays.sort(a);//从小到大排列
        for(int x:a)
        {
            System.out.print(x+" ");
        }
        
        System.out.println();
        */
         Arrays.sort(a,cmp);//从小到大排列
        for(int x:a)
        {
            System.out.print(x+" ");
        }
        System.out.println();
        
        /* char c[]=new char[] {'s','F','g','V','x','m'};
        Arrays.sort(c);//大写字母排在小写字母前
        for(char y:c)
        {
            System.out.print(y+" ");
        }
        */
    }

}

 第三天:

今天主要自学了一下复制数组和查询数组

复制数组语法:

type[] a=Arrays.copyOf(arr ,int length(所要复制的长度))

type[] a=Arrays.copyOfRange(arr ,int x(开始复制的位置),int y（复制结束的位置不包括次位置的元素）)

import java.util.Arrays;

public class 数组复制 {
    public static void main(String[] args) {
        int a[]=new int[] {1,2,3,4,5,6};
        int b[]=Arrays.copyOf(a,6);//将a全部复制给b
        int c[]=new int[3];
        int d[]=new int[9];
        c=Arrays.copyOf(a,5);
        d=Arrays.copyOf(a,5);//对一个已定长度的数组，将一个数组复制给他，其长度将变为被复制的数组中被复制元素的个数
        int f[]=Arrays.copyOf(a, 3);//截至到第三个元素
        int g[]=Arrays.copyOf(a, 9);//被复制数组长度不够自动补0
        char[] h=new char[] {'h','e','l','l','o'};
        char[] i=Arrays.copyOf(h, 3);
        char[] j=Arrays.copyOf(h, 8);//被复制数组长度不够部null
        char[] k=new char[3];
        char[] l=new char[8];
        k=Arrays.copyOf(h, 5);//长度强制转化
        l=Arrays.copyOf(h, 5);//长度强制转换
        for(int x:b)
        {
            System.out.printf("%3d",x);//宽域为3右对齐输出
        }
        System.out.println();
        for(int x:c)
        {
            System.out.printf("%-3d",x);//宽域为3左对齐输出
        }
        System.out.println();
        for(int x:d)
        {
            System.out.printf("%3d",x);//宽域为3右对齐输出
        }
        System.out.println();
        for(int x:f)
        {
            System.out.printf("%3d",x);//宽域为3右对齐输出
        }
        System.out.println();
        for(int x:g)
        {
            System.out.printf("%3d",x);//宽域为3右对齐输出
        }
        System.out.println();
        for(char x:i)
        {
            System.out.printf("%3c",x);//宽域为3右对齐输出
        }
        System.out.println();
        for(char x:j)
        {
            System.out.printf("%3c",x);//宽域为3右对齐输出
        }
        System.out.println();
        for(char x:k)
        {
            System.out.printf("%3c",x);//宽域为3右对齐输出
        }
        System.out.println();
        for(char x:l)
        {
            System.out.printf("%3c",x);//宽域为3右对齐输出
        }
        System.out.println();


    }
}

查询数组语法：

int index=Arrays.binarySearch(arr,n(要查询的元素))//在全部元素中搜索

int index=Arrays.binarySearch(arr,int x,int y,int n)//在x到y-1内搜索

package 正规军;
import java.util.Arrays;
public class 查询数组 {
    public static void main(String[] args)
    {
        int a[]=new int[] {9,3,6,7,4,8,1,8};
        int e=Arrays.binarySearch(a,-10);
        int f=Arrays.binarySearch(a,10);
        Arrays.sort(a);
        for(int x:a)
        {
            System.out.printf("%3d",x);
        }
        System.out.println();
        int b=Arrays.binarySearch(a,5);
        int c=Arrays.binarySearch(a,6);
        int d=Arrays.binarySearch(a,8);
        //int g=Arrays.binarySearch(a,0,7,9);//不搜索a[7];
        int g=Arrays.binarySearch(a,1,7,0);
        System.out.println(b);//插入该数后第一个大于所找数的索引位置
        System.out.println(c);//索引位置(从0开始)
        System.out.println(d);//有相同的无法确定是哪一个
        System.out.println(e);//不在数组内且大于数组中的每一个元素返回-（length+1）
        System.out.println(f);//小于每一个数组元素返回-1
        System.out.println(g);//同样从0开始计算，若大于索引范围内的每一个元素，返回的索引值是-（结尾处的位置+1），若小于范围内的每一个元素，返回的索引值是-（索引开头位置+1）
        
    }
}

然后做了几道题

一.

package 正规军;

public class 数组排序算法 {
    public static void main(String[] args)//static主方法调用其他不是静态的方法得通过对象（目前理解）
    {
        int[] a=new int[] {22,32,45,12,47,3,29,6,43};
        数组排序算法 b=new 数组排序算法();
        b.sort1(a);
        b.sort2(a);
        b.rollback(a);
    }
    public void sort1(int a[])//从小到大冒泡排序
    {
        for(int i=1;i<a.length;i++)//注意a.[a.length+1]不包含在数组内
        {
            for(int j=0;j<a.length-i;j++)
            {
                int temp;
                if(a[j]>a[j+1])//前者比后者大就交换位置
                {
                    temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
        }
        showArrays(a);
    }
    public void showArrays(int[] a)//打印排列好的数组
    {
        for(int i:a)
        {
            System.out.printf("%-3d",i);//左对齐宽域为3
        }
        System.out.println();
    }
    public void sort2(int[] a)//选择排序从大到小
    {
        for(int i=0;i<a.length-1;i++)//最后一个数的时候可以进行不循环
        {
            for(int j=i;j<a.length;j++)//完成每次循环后都可以少比较前面的一个数
            {
                int temp;
                if(a[i]<a[j])//找出每次循环中所有数的最大数放到本次循环的第一个位置
                {
                    temp=a[i];
                    a[i]=a[j];
                    a[j]=temp;
                }
            }
        }
        showArrays(a);
    }
    public void rollback(int[] a)//反转数组
    {
        for(int i=0;i<a.length/2;i++)//只要循环数组长度的一半次
        {
            int temp;
            temp=a[i];
            a[i]=a[a.length-1-i];
            a[a.length-1-i]=temp;
        }
        showArrays(a);
    }
}

二.

package 正规军;

public class 矩阵转置 {
    public static void main(String[] args)
    {
        int a[][]=new int[][]{{91,25,8},{56,14,2},{47,3,67}};
        矩阵转置 b=new 矩阵转置();
        b.show(a);
        System.out.println();
        b.transpose(a);
        b.show(a);
    }
    public void transpose(int[][] a)//行换列，列换行
    {
        for(int i=0;i<a.length;i++)
        {
            for(int j=0;j<i;j++)
            {
                int temp=a[i][j];
                a[i][j]=a[j][i];
                a[j][i]=temp;
            }
        }
    }
    public void show(int a[][]) {
        for(int i=0;i<a.length;i++)
        {
            for(int j=0;j<a[i].length;j++)
            {
                System.out.printf("%3d",a[i][j]);
            }
            System.out.println();
        }
    }
}

三.

import java.util.Scanner;
public class 杨辉三角 {
    public static void main(String[] args)
    {
        Scanner sc=new Scanner(System.in);
        int a=sc.nextInt();
        int triangle[][]=new int[a][a];
        for(int i=0;i<triangle.length;i++)
        {
            for(int j=0;j<=i;j++)
            {
                if(j==0)
                {
                    triangle[i][j]=1;
                }
                else
                {
                    triangle[i][j]=triangle[i-1][j]+triangle[i-1][j-1];
                }
            }
        }
        for(int x[]:triangle)
        {
            for(int y:x)
            {
                if(y!=0)
                System.out.printf("%-4d",y);
            }
            System.out.println();
        }
    }
}

还有一个以前没有尝试过的小游戏，属于地图硬件等比较固定的

import java.util.Scanner;
public class 推箱子 {
    public static void main(String[] args)
    {
        char area[][]=new char[8][10];
        推箱子 b=new 推箱子();
        b.initial(area);
        int x=1,y=1,x1=2,y1=2;
        Scanner sc=new Scanner(System.in);
        b.show(area);
        while(true)
        {
            char operate=sc.next().charAt(0);//很麻烦，输入一次得按一次回车，以后学了更多有机会就改改
            area[y][x]=' ';//先消除掉原位置的&
            switch(operate) //控制人推箱子移动，几下移动前后的坐标
            {
            case 'w':
                if(area[y-1][x]!='H')//人前是墙不能走，人推箱子前面是墙不能走，
                {
                    if(area[y-1][x]=='o')
                    {
                        if(area[y-2][x]!='H')
                        {
                            area[y1][x1]=' ';//人推箱子发现前面是空就消除原位置的o
                            y1--;
                            y--;
                        }
                    }
                    else y--;
                }
                break;
            case 's':
                if(area[y+1][x]!='H')
                {
                    if(area[y+1][x]=='o')
                    {
                        if(area[y+2][x]!='H')
                        {
                            area[y1][x1]=' ';
                            y1++;
                            y++;
                        }
                    }
                    else y++;
                }
                break;
            case 'a':
                if(area[y][x-1]!='H')
                {
                    if(area[y][x-1]=='o')
                    {
                        if(area[y][x-2]!='H')
                        {
                            area[y1][x1]=' ';
                            x1--;
                            x--;
                        }
                    }
                    else x--;
                }
                break;
            case 'd':
                if(area[y][x+1]!='H')
                {
                    if(area[y][x+1]=='o')
                    {
                        if(area[y][x+2]!='H')
                        {
                            area[y1][x1]=' ';
                            x1++;
                            x++;
                        }
                    }
                    else x++;
                }
                break;
            }
            area[y1][x1]='o';//移动完成后通过坐标位置再次录入人和箱子
            area[y][x]='&';
            b.show(area);
            if(x1==5&&y1==6)
            {
                System.out.println("Victory");//当箱子的坐标和重点坐标重合后，游戏结束
                break;
            }
        }
    }
    public void initial(char[][] area)//将地图初始化
    {
        for(int i=0;i<8;i++)//墙
        {
            for(int j=0;j<10;j++)
            {
                if(i==0||i==7||j==0||j==9)
                    area[i][j]='H';
                else
                    area[i][j]=' ';
            }
        }
        area[1][3]='H';
        area[2][3]='H';
        area[3][3]='H';
        area[5][4]='H';
        area[5][5]='H';
        area[5][6]='H';
        area[4][8]='H';
        area[3][5]='H';
        area[3][6]='H';
        area[3][8]='H';
        area[2][5]='H';
        area[6][4]='H';
        area[1][1]='&';//人的位置
        area[2][2]='o';//箱子位置
        area[6][5]='*';//出口位置
    }
    public void show(char[][] area)//显示
    {
        for(char x[]:area)
        {
            for(char y:x)
            {
                System.out.printf("%c",y);
            }
            System.out.println();
        }
    }
    /*本来想直接用这个来改人的位置的，但是形参改变不会改变形参，Java的引用类和C++不一样，所以先不用函数来写这个
    public void move(char[][] area,int x,int y)//每一步的规则
    {
        char operate=sc.next().charAt(0);
        area[y][x]=' ';
        switch(operate) {
        case 'w':
            if(area[y+1][x]!='H')
                y++;
            break;
        case 's':
            if(area[y-1][x]!='H')
                y--;
            break;
        case 'a':
            if(area[y][x-1]!='H')
                x--;
            break;
        case 'd':
            if(area[y][x+1]!='H')
                x++;
            break;
        }
        area[y][x]='&';
    }
    */
}

 第四天：

主要完成了一些练习题

一.

import java.util.Scanner;
public class 自动批卷 {
    public static void main(String[] args)
    {
    char a[][]=new char[][] {{'B','A','D','C','C','B','C','A','D','B'},{'B','A','D','B','A','B','C','A','C','B'},{'B','A','D','B','A','B','C','A','C','B'},{'B','A','D','B','A','B','C','A','C','B'},{'B','A','D','B','A','B','C','A','C','B'},{'B','A','D','B','A','B','C','A','C','B'},{'B','A','D','B','A','B','C','A','C','B'},{'B','A','D','B','A','B','C','A','C','B'},{'B','A','D','B','A','B','C','A','C','B'},{'B','A','D','B','A','B','C','A','C','B'}};
    Scanner sc=new Scanner(System.in);
    自动批卷 b=new 自动批卷();
    while(true)
    {
        System.out.println("您想调取第几位成绩的答题结果(有效数字范围是1~8)");
        int x=sc.nextInt();
        b.judge(a, x);
    }
    }
    public void judge(char a[][],int x)//用来批卷
    {
        int j=0;
        System.out.printf("第%d位同学的全部答案为：\n",x);
        for(int i=0;i<a[0].length;i++)
        {
            System.out.printf("%2c", a[x][i]);
            if(a[0][i]==a[x][i])
            {
                j++;
            }
        }
        System.out.printf("\n第%d位同学一共答对了%d道题\n\n\n",x,j);
    }
}

二.

import java.util.Scanner;
public class 统计学生成绩 {
    public static void main(String[] args)
    {
        Scanner sc=new Scanner(System.in);
        double a[][]=new double[3][6];
        for(int i=0;i<a.length;i++)//输入成绩
        {
            int j=0,sum=0;
            double ave;
            System.out.printf("请输入第%d个学生的编号:\n",i+1);
            a[i][j]=sc.nextDouble();
            j++;
            System.out.println("请输入语文成绩:");
            a[i][j]=sc.nextDouble();
            sum+=a[i][j];
            j++;
            System.out.println("请输入数学成绩:");
            a[i][j]=sc.nextDouble();
            sum+=a[i][j];
            j++;
            System.out.println("请输入英语成绩:");
            a[i][j]=sc.nextDouble();
            sum+=a[i][j];
            ave=sum/3.0;
            j++;
            a[i][j]=ave;
            j++;
            a[i][j]=sum;
            System.out.println();
        }
        System.out.println("------------------------------------------------------");
        System.out.println("学生编号  语文成绩  数学成绩  英语成绩  平均成绩  总成绩");
        for(int i=0;i<a.length;i++)
        {
            for(int j=0;j<a[i].length;j++)
            {
                if(j==4)
                    System.out.printf("%-8.2f",a[i][j]);
                else
                    System.out.printf("%-8.0f",a[i][j]);
            }
            System.out.println();
        }
    }
}

三.

import java.util.Scanner;
import java.util.Arrays;
public class 客车售票 {
    public static void main(String[] args)
    {
        Scanner sc=new Scanner(System.in);
        char[][] seat=new char[9][4];
        int x,y;
        //Arrays.fill(seat[0],seat[0][0]+9*4,'1');是错误的，fill只能用来填充一维数组
        客车售票 b=new 客车售票();
        b.initial(seat);
        b.show(seat);
        while(true)
        {
            System.out.print("请输入要预定的行号:");
            x=sc.nextInt();
            System.out.print("请输入要预定的列号:");
            y=sc.nextInt();
            b.book(seat,x,y);
            b.show(seat);
        }
    }
    public void initial(char[][] seat)
    {
        for(int i=0;i<seat.length;i++)
        {
            Arrays.fill(seat[i],'1');
        }
    }
    public void show(char[][] seat)//显示当前车上座位情况
    {
        System.out.println("          简单客车售票系统");
        System.out.println("        9排4列的客车开始售票");
        for(char x[]:seat)
        {
            for(char y:x)
            {
                System.out.printf("%-10c",y);
            }
            System.out.println();
        }
    }
    public void book(char[][] seat,int x,int y)
    {
        if(seat[x-1][y-1]!='0')
        {
            seat[x-1][y-1]='0';
            System.out.println("\n预定成功!\n\n");
        }
        else {
            System.out.println("\n预定失败，该位置已有其他乘客!\n\n");
        }
    }
}

还有一个比较复杂的小游戏

import java.util.Scanner;
public class 五子棋
{
    public static void main(String[] args)
    {
        Scanner sc=new Scanner(System.in);
        char[][] area=new char[11][11];
        五子棋 b=new 五子棋();
        b.initial(area);
        b.show(area);
        int x,y,z=0;
        System.out.println("白子先行:");
        boolean flag=false;
        while(!flag)
        {
            x=sc.nextInt();
            y=sc.nextInt();
            if((x<=9&&x>=0)&&(y<=9&&y>=0))//所下的数字在棋盘内
            {
                if(z%2==0)//划分黑白子，白子先行
                {
                    if(area[y+1][x+1]==' ')//棋盘上每棋子才能下
                    {
                        area[y+1][x+1]='o';
                        z++;//落子后才能换方
                    }
                    else//原棋盘有棋子就得换一个位置
                        System.out.println("请重新落子");
                }
                else
                {
                    if(area[y+1][x+1]==' ')
                    {
                        area[y+1][x+1]='*';
                        z++;
                    }
                    else
                        System.out.println("请重新落子");
                }
                b.show(area);
                flag=b.victor(area,x,y);
                if(flag)//判断胜利方
                {
                    if(area[y+1][x+1]=='o')
                        System.out.println("白子胜利");
                    else
                        System.out.println("黑子胜利");
                }
            }
            else 
                System.out.println("请重新落子");
        }
    }
    public void initial(char[][] area)//初始化棋盘
    {
        //想把原来数组中的所有的值都先改成' '，但是发现for(char x:arr)这种模式无法改变原数组的值
            /*for(char x[]:area)
            {
                for(char y:x)
                {
                        y=' ';
                }
            }*/
        for(int i=0;i<area.length;i++)//将原棋盘所有的位置都置为' '
        {
            for(int j=0;j<area[i].length;j++)
            {
                area[i][j]=' ';
            }
        }
            for(int i=0;i<area.length;i++)//给棋盘下的位置做标识
            {
                area[i][0]=(char)('0'+i-1);
                area[0][i]=(char)('0'+i-1);
            }
    }
    public void show(char[][] area)//显示棋盘
    {
        System.out.println("----------------------");
        for(int i=0;i<area.length;i++)
        {
            for(int j=0;j<area[i].length;j++)
            {
                System.out.printf("%2c",area[i][j]);
            }
            System.out.println();
        }
        System.out.println("----------------------");
    }
    
    public boolean victor(char[][] area,int x,int y)//判断是否胜利
    {
        int num=1;
        char color=area[y+1][x+1];
        int i=1;
        boolean flag=false;
        /*
         * 判断列上是否相连
         */
        while(area[y+1-i][x+1]==color)
        {
            num++;
            i++;
        }
        i=1;
        while(area[y+1+i][x+1]==color)
        {
            num++;
            i++;
        }
        if(num>=5)
        {
            flag=true;
        }
        /*
         * 归1后开始判断行
         */
        num=1;
        i=1;
        while(area[y+1][x+1-i]==color)
        {
            num++;
            i++;
        }
        i=1;
        while(area[y+1][x+1-i]==color)
        {
            num++;
            i++;
        }
        if(num>=5)
        {
            flag=true;
        }
        /*
         * 斜率为正的斜线
         */
        num=1;
        i=1;
        while(area[y+1-i][x+1+i]==color)
        {
            num++;
            i++;
        }
        i=1;
        while(area[y+1+i][x+1-i]==color)
        {
            num++;
            i++;
        }
        if(num>=5)
        {
            flag=true;
        }
        /*
         * 斜率为负的斜线
         */
        num=1;
        i=1;
        while(area[y+1-i][x+1-i]==color)
        {
            num++;
            i++;
        }
        i=1;
        while(area[y+1+i][x+1+i]==color)
        {
            num++;
            i++;
        }
        if(num>=5)
        {
            flag=true;
        }
        return flag;
    }
}

 第五天:

今天主要学了java中的类的基本元素和方法等内容

总的来说，Java中的主方法是Java这个类执行的方法，类的执行方法是体现在主函数中，类中的其他方法都是在类的主函数中实现的只有主方法调用了其他方法，其他方法才会执行。

还有就是，主方法是一个静态的方法，其他方法只有是静态的才能被主方法直接调用，非静态方法只能通过对象调用。

Java类的构造函数默认为无参的构造，可以通过使用自己编写的有参的构造实现无参有默认值的构造。

Java中的this是一种引用，可以用this.的方法调用类中的元素，直接this也可以调用自己编写的构造函数 ，返回值为this也可以返回对象

主方法的形参是String类型的数组，可以通过其他类或者编译器给他赋值。

public class kfc {
    int ice;
    public kfc()
    {
        this(0);
    }
    public kfc(int ice)
    {
        this.ice=ice;
    }
    public static void main(String[] args)
    {
        kfc coke=new kfc();
        kfc coke1=new kfc(3);
        System.out.println(coke.ice);
        System.out.println(coke1.ice);
    }

}
public class pool {
    static int water=0;
    static void add()
    {
        water+=3;
    }
    static void minus()
    {
        water-=2;
    }
    static void show()
    {
        System.out.println(water);
    }
    public static void main(String[] args)
    {
        add();
        minus();
        minus();
        add();
        show();
    }
}
public class kfc {
    int ice;
    public kfc()
    {
        this(0);
    }
    public kfc(int ice)
    {
        this.ice=ice;
    }
    public static void main(String[] args)
    {
        kfc coke=new kfc();
        kfc coke1=new kfc(3);
        System.out.println(coke.ice);
        System.out.println(coke1.ice);
    }

}
public class consume {
    public static void main(String[] args)
    {
        consume a[]=new consume[7];//类的数组初始化得分成两步
        for(int i=0;i<7;i++)
        {
            a[i]=new consume(1992.0);
            a[i].show();
        }
        System.out.println("您最近有"+count+"笔交易。");
    }
    public static int count=0;
    private double money;
    public consume(double money)
    {
        this.money=money;
        count++;
    }
    public double getmoney()
    {
        return money;
    }
    public void show()
    {
        System.out.println("您有一笔大额消费，交易金额:"+getmoney()+"元。");
    }
    
}
package 类;
import java.util.Scanner;
public class bigsmall {
    public static void main(String[] args)
    {
        for(int i=0;i<args.length;i++)
            {
            args[i].toUpperCase();//不改变原串内的值
            System.out.print(args[i].toUpperCase()+" ");
            }

    }
}
package 类;

import java.util.Scanner;

public class newMain {
    public static void main(String[] args) {
//        if(args[0]=="张三"||args[1]=="123456")用'=='比较的是String类型的位置不能直接用'=='比复合数据类型
//        {
//            System.out.println("开始执行···");
//        }
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入账号:");
        String zhanghao=sc.next();
        System.out.println("请输入密码:");
        String mima=sc.next();
        if(zhanghao.equals(args[0])&&mima.equals(args[1]))
        {
            System.out.println("开始执行···");
        }
        else
            System.out.println("您的权限无法运行此程序");
    }
}

 第六天：

今天早上6点起床就去赶校车去驾校考科目一，到了后就等了一个多小时才开始考，考个十几分钟考完后出考场就刚好走了一趟校车，于是只能等坐十一点半的校车回去

下午因为太困了就睡了会，起来后想做几道练习没多久就就被叫去帮别人填志愿去了

直到晚上才有时间做几道简单的练习

类的构造使用：

package 类;

public class math {
    public static void main(String[] args)
    {
        double c,d;
        math a=new math(45.6);
        math b=new math(0.35);
        System.out.println(a.power());
        System.out.println(b.power());
    }
    private double num;
    public math(double num)
    {
        this.num=num;
    }
    public double power ()
    {
        return this.num*this.num*this.num*this.num;
    }
}

静态方法的调用

package 类;

public class computer {
    public static void main(String[] args)
    {
        add(4.4,7.11);
        minus(8.9,2.28);
        plus(5.2,13.14);
        chu(92,89);
        
    }
    public static void add(double x1,double x2)
    {
        System.out.println(x1+"加上"+x2+"的结果:"+(x1+x2));
    }
    public static void minus(double x1,double x2)
    {
        System.out.println(x1+"加上"+x2+"的结果:"+(x1-x2));
    }
    public static void plus(double x1,double x2)
    {
        System.out.println(x1+"加上"+x2+"的结果:"+(x1*x2));
    }
    public static void chu(double x1,double x2)
    {
        System.out.println(x1+"加上"+x2+"的结果:"+(x1/x2));
    }
}

学生信息录入和计算平均分

package 类;
import java.util.Scanner;
public class 计算平均分 {
    public static void main(String[] args)
    {
        Scanner sc=new Scanner(System.in);
        计算平均分 a[]=new 计算平均分[4];//声明一个类数组
        for(int i=0;i<a.length;i++)
        {
            int x;
            String y;
            double z,t,l;
            x=sc.nextInt();
            y=sc.next();
            z=sc.nextDouble();
            t=sc.nextDouble();
            l=sc.nextDouble();
            a[i]=new 计算平均分(x,y,z,t,l);//调用构造函数给创建的类初始化
            a[i].average();
            //System.out.println(a[i].English);本类方法中可以直接调用本类的私有数据
        }
        System.out.println("学号    姓名     语文    数学    英语    平均分");
        System.out.println("-----------------------------------------");
        for(计算平均分 i:a)
        {
            i.show();
        }
    }
    private int num;
    private String name;
    private double Chinese;
    private double math;
    private double English;
    private double ave;
    public 计算平均分(int num,String name,double Chinese,double math,double English)
    {
        this.num=num;
        this.name=name;
        this.Chinese=Chinese;
        this.math=math;
        this.English=English;
    }
    public void average()
    {
        ave=(Chinese+math+English)/3;
    }
    public void show()
    {
        System.out.printf("%-7d%-7s%-7.1f%-7.1f%-7.1f%-7f\n",num,name,Chinese,math,English,ave);
    }
}

 第七天:

首先先是完成了几道简单的题目

首先是判断有没有运行时参数

package 类;

public class yes {
    public static void main(String[] args)
    {
        if(args.length==0)//字符串数组长为0就时不存在运行时参数
        {
            System.out.println("无运行时参数");
        }
        else
        {
            for(String x:args)
            {
                System.out.println(x);
            }
        }
    }
}

还通过例题了解了面向对象中的一种特殊的类，单例类

单例类只能实例化有限个对象，并且其对象不是通过构造方法实例化的，其构造方法不能被外界调用，这样此类实例化方式只有通过成员函数。

package 类;

public class 单例类 //只实例化一个对象
{
    private String name;
    private static 单例类 Instance;//缓存曾经创造过的实例
    private 单例类(String name)
    {
        this.name=name;
        //用private将构造函数隐藏起来,避免通过构造函数创建该类
    }
    public static 单例类 getInstance(String a)
    {
        if(Instance==null)//确保只能创建一个
        {
            Instance=new 单例类(a);
        }
        return Instance;
    }
    public static void main(String[] args)
    {
        单例类 s1=getInstance("张润泽");//先实例化
        单例类 s2=getInstance("付海旭");//因为已经存在一个对象了所以不会实例化
        System.out.println(s1==s2);
        System.out.println(s1.name);
        System.out.println(s2.name);
    }
}

然后今天还了解了一下类的继承，Java中类的继承和C有些不同，首先就是Java中的类只能有一个父类，然后就是Java中是通过方法super()来调用父类的有参构造方法，否则就是调用无参的构造方法。

Java中的类的构造顺序同C++先调用父类的构造再调用子类的构造。

package 水果;

public class 普通水果 {
    protected double price;
    普通水果(double a)
    {
        price=a;
    }
    普通水果()
    {
        this(3);
    }
    void showPrice()
    {
        System.out.println(price);
    }
}

package 水果;

public class 人工包装 extends 普通水果{
    double pricemax=2*price;
    public static void main(String[] args)
    {
        人工包装 a=new 人工包装(2);
        System.out.println(a.price+" "+a.pricemax);//子类可以直接访问父类的公有数据和保护类型数据
    }
    人工包装 (double price)//先调用父类构造在调用子类构造
    {
        //super(2);//调用子类构造函数
        /*
         * 有了super后就不会自动调用父类的无参构造了
         */
        this.price=price;//顺序是,先调用父类的无参构造器有price=3;然后再创建子类变量pricemax=2*price,最后再调用子类构造price=2;
    }
}

最后就是Java中的万类之父（自己这样叫的）：Object类

Object是所有类的父类无论是Java中的String等自带的类还是我们自己创建的类，都是继承于Object的，所以，所有的类都可以调用Object中的函数

1.getClass()方法，返回对象执行的Class实例，也就是返回的是一种类的类型，getName()返回此类的名称，后者只能在前者的基础上使用

package 类的继承;
public class getclass {
    public static void main(String[] args)
    {
        getclass a=new getclass();
        System.out.println(a.getClass());
        System.out.println(a.getClass().getName());
    }
}

运行结果：

class 类的继承.getclass

类的继承.getclass

 2.toString方法，将一个类返回字符串形式，在某些场合下会自动调用，可以于getClass()联合使用，可以按自己的需求重写

package Object类;

public class tostring {
    String name;
    String type;
    public tostring(String name,String type)
    {
        this.name=name;
        this.type=type;
    }
    public String toString()//重载Object类中的toString
    {
        return "我是"+name+",我是个"+type+".";
    }
    public static void main(String[] args)
    {
        tostring a=new tostring("弓长氵闰泽","变态");
        tostring b=new tostring("吕布","背信弃义,卖主求荣的小人");
        System.out.println(a);//转化为字符串,自动调用toString相当于a.toString();
        System.out.println("大家好,"+b);//转化为与字符串连接
        System.out.print(a+"\n");
        System.out.printf("%s",a);
    }
}
package Object类;

public class fruit {
    String apperance;
    String name;
    double price;
    double weight;
    double sum;
    public fruit(String apperance,String name,double price,double weight)
    {
        this.apperance=apperance;
        this.name=name;
        this.price=price;
        this.weight=weight;
        sum=price*(weight/500);
    }
    public String toString()
    {
        return apperance+"被称为“"+name+"”，每500克"+price+"元，买了"+weight+"克“"+name+"”，需支付"+sum+"元。";
    }
    public static void main(String[] args)
    {
        fruit a=new fruit("红色的苹果","糖心富士",4.98,2500);
        System.out.println(a);
    }
}

 

3.equals()方法，比较对象的方式，比较的是对象的实际内容，而"=="比较的是对象的地址，equals()可以按自己的需求重写比较方法

package Object类;

public class absurd //要求比的猫和狗同类
{
    String name;
    int num;//号码牌
    public absurd(String name,int num)
    {
        this.name=name;
        this.num=num;
    }
    public boolean equals(Object obj)
    {
        if(this==obj)//判断是否存于同一地址
            return true;
        if(obj==null)//判断是否为空类
            return false;
        if(getClass()!=obj.getClass())
            return false;
        absurd a=(absurd) obj;//强制转化为同类对象
        if(this.num!=a.num)//注意这里不能用obj.num来代替，这里的obj是一个未确定类型的类
            return false;
        return true;
    }
    public static void main(String[] args)
    {
        absurd a=new absurd("猫",1);
        absurd b=new absurd("狗",1);
        System.out.println("猫和狗是否为同类:"+a.equals(b));
    }
}

这些就是我这周学习的内容，下一周计划学习完成类的多态抽象与借口，并了解一些包和内部类的知识。