A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

Day X
今天学习了随机数和数组的相关知识
随机数在之前的学习中学习过,所以今天学起来比较轻松
随机数的使用方法
1,导包  import  java.util.Random;
2,创建对象 Randomrandom = new Random();
3,接收 int number= random.nextInt(x); //这里的x表示取值域,是左闭右开结构
这是今天练习随机数只是的代码
importjava.util.Random;
public classrandomDemo {
   public static voidmain(String[] args) {
     // boss血量1000,攻击力3-14,暴击为翻倍攻击力(攻击力为3的倍数时暴击),并显示暴击的数字,求多少次打死boss
      int boss = 1000;
      int count = 0;
      while(boss>0){
          Random r = new Random();
          int att = r.nextInt(12)+3;
          if(att%1==0){
             att*=2;
             System.out.println("暴击"+att);
          }
          boss = boss-att;
          count++;
      }
      System.out.println("攻击的次数"+count);
   }
}
回复 使用道具 举报


代码2:
import java.util.Random;
import java.util.Scanner;
public class randomDemo_ex {
      /**
       * 博彩游戏强化版
       * 添加了作弊码功能--在压大压小环节输入"+7",即可启动!
       * 新添了诸多bug
       * @param +7
       */
   public static void main(String[] args) {
      // 博彩游戏,让用户猜大小,猜中获得押注*2的金额;没钱时break;
      Scanner sc = new Scanner(System.in);
      Random r = new Random();
      int money = 500;
      String zuobima = "+7";
      int a = 0;
      boolean flag = false;
      while(true){
          System.out.println("您现在拥有"+money+"金额");
          System.out.println("您要压多少?");
          int guessmoney = sc.nextInt();
          if(guessmoney<=0){
             System.out.println("押注金额有误!");
             System.out.println();
             continue;
          }
          if(guessmoney>money){
             System.out.println("您没有那么多金额,请充值");
             System.out.println();
          }else{
             money = money-guessmoney;
             System.out.println("您压大(1)还是压小(0)?");
             int choose = sc.nextInt();
             if(choose == 0){
                System.out.println("您压了小");
                System.out.println();
             }else if(choose == 1){
                System.out.println("您压了大");
                System.out.println();
             }else if(zuobima.equalsIgnoreCase("+7")){
                System.out.println("启用作弊码!");
                flag = true;
                System.out.println();
                System.out.println("请输入要增加的金额");
                a = sc.nextInt();
                money = money+a;
             }else{
                System.out.println("只有大和小你还想压什么?");
                System.out.println();
                money = money+guessmoney;
                continue;
             }
             int num = r.nextInt(2);
             if(num == choose){
                System.out.println("恭喜您,猜中了!");
                System.out.println();
                money = money+(guessmoney*2);
                flag = false;
             }else if(flag == true){
                System.out.println("作弊码开启成功!!您已成功增加"+a+"金额");
                flag = false;
             }else{
                System.out.println("可惜,没中");
                System.out.println();
                flag = false;
             }
             if(money<=0){
                System.out.println("您的金额已经为零,请充值");
                break;
             }
          }
      }
   }
}

回复 使用道具 举报


第二个代码呢,自己化身野生戏精,加了点戏,开了一个作弊模式.仅供娱乐和练习代码使用.
随机数的练习就到这里,然后就是数组的学习,今天学习了一维数组和二维数组
首先是数组的概念:
数组是存储同一种数据类型多个元素的容器。
数组既可以存储基本数据类型,也可以存储引用数据类型
定义数组的格式:
虽然有几种写法,但是这里只写一种动态定义和一种静态定义
动态: 数据类型[] 数组名 = new 数据类型[x];  //这里的x是数组的长度
静态: 数据类型[] 数组名 = {x,x,x…..}   //这里的x是详细的元素数据
然后下面是一维数组的简单应用的代码,有的是练习题,有的是作业题
代码1:
代码2:
代码3:
接下来学习了二维数组的相关知识
二维数组的概念: 二维数组其实就是一个元素为一维数组的数组。
二维数组的定义格式: 数据类型[][] 数组名 = new 数据类型[m][n];
然后做了一下有关二位数组的相关练习题
二维数组遍历:
public class arrarrDemo1 {
   public static void main(String[] args) {
      // 遍历二维数组
      int[][] arr = {{1,2,3,4,5},{6,7,8,9,10},{11,12,13,14,15},{16,17,18,19,20},{21,22,23,24,25}};
//    int[][] arr = new int[5][5];
      int count = 0;
      for(int i=0;i<arr.length;i++){
          for(int j=0;j<arr[i].length;j++){
             System.out.print(arr[i][j]+"\t");
             count++;
          }
          if(count%5==0){
             System.out.println();
          }
      }
   }
}
其实二维数组这块涉及到for的嵌套我就有点头疼,看来还是for循环这一块的知识掌握的不够牢固.下来应该再多加练习.然后就是感觉自己的逻辑思维有点差,很多问题一下子想不清楚,代码的层次感很差.

回复 使用道具 举报
继续加油 加油 加油
回复 使用道具 举报
回复 使用道具 举报
前天的日志好像少了几张练习题的代码,这里补充一下
代码1

代码2

代码3

回复 使用道具 举报
Dayx
今天学习了方法的相关基础知识
1,方法的概念:方法是完成某个功能的代码块,函数在java中被称为方法.
2,定义方法的格式:
修饰符(目前只用到public static)    返回值类型       (参数类型参数名,参数类型,参数名2…..){
      函数体;
      return 返回值;
}
修饰符目前只用到public static
返回值类型就是用于限定返回值的数据类型
方法名是调用方发所用到的名字
参数类型是指接收数据的数据类型
参数名是接收数据时的变量
函数体就是方法体,也就是完成功能所需要的代码块
Return返回值是结束方法,将返回值带回给调用者
调用方法:
1,单独调用
2,输出调用
3,赋值调用
比较推荐赋值调用,因为在主函数结束前,可以对返回值进行任意操作.
下面是一下课上的代码练习
public static void main(String[] args) {
      // 数组元素查找,查找指定元素在数组中第一次出现的位置
      //定义一个数组,并初始化
      /*写一个方法,实现:
       * 遍历数组,得到数组中的每一个元素,和已知的数据进行比较
       * 如果相等,就返回索引值
       */
      int[] arr = {1,2,3,4,5,6,7,8,9};
      int index = getIndex(arr, 5);
      System.out.println(index);
   }
   
   public static int getIndex(int[] arr,int value){
      int index = 0;
      for(int i=0;i<arr.length;i++){
          if(arr[i]==value){
             return i;
          }
      }
      return -1;
   }
}
public static void main(String[] args) {
      // 用方法写一个遍历数组
      int[] arr = {1,2,3,4,5};
      print(arr);
   }  
   public static void print(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]+",");
          }
      }
   }
}


回复 使用道具 举报
这里有几点需要注意,有固定返回值类型的方法,调用时三种调用方法都可以用,但是如果返回值类型是void,就只能单独调用.
接下来学习了方法重载
对于方法的功能一样,参数列表不同的情况,java允许其方法名一致,用来做到,见名知意.
            叫做 方法重载
            java会根据不同的参数列表去掉用不同的方法
            举个例子------写两个方法,一个统计两个数据的和,另一个统计四个数据的和
            所以,方法重载:
             * 在同一个类中,方法名相同,参数列表不同,与返回值类型无关
             * 参数列表不同:
             * A:参数个数不同
             * B:参数类型不同
public static void main(String[] args) {
      System.out.println(sum(30, 40));
      System.out.println(sum(30, 40, 50, 60));
   }
   public static int sum(int a,int b) {
      return a+b;
   }
   public static int sum(int a,int b,int c,int d) {
      return a+b+c+d;
   }
}
关于数据传递的知识
对于基本数据类型,方法中所做的任何操作,和主方法中的无关
但是对于引用数据类型,方法中所做的操作是能影响到主方法中的.
举个例子
public static void main(String[] args) {
      // 数据传递
      int a = 10;
      int b = 20;
      System.out.println(sum(a, b));
      System.out.println(a);             //最后执行这两步打印,可以看出在方法中所做的增减和主方法中的基本数据类型数值无关
      System.out.println(b);
     
   }
   public static int sum(int a,int b){
      System.out.println(a);
      System.out.println(b);
      a +=100;
      b +=100;
      System.out.println(a);
      System.out.println(b);
      return a+b;
   }
今天因为自己之前预习的原因,所以知识接收的比较快,没有什么大问题,希望以后能将预习的学习习惯保持下去,有助于课堂知识的消化.也希望同学们(虽然大佬们已经预习到了就业班的内容TAT)能够养成预习的好习惯~

回复 使用道具 举报
期待你每天的进步   温故而知新
回复 使用道具 举报
昨天进行了基础班阶段性测验今天分数出来了,考的还行,96分,排名第三.

首先看下错题
单选题第一道就错了,很僵硬

1、分析以下代码,以下哪个选项是正确( )                       
public class Test {
    public static void main(String[] args) {
        double d = 84.54;
        d++;
        int c = d / 2;
                System.out.println(c);
    }
}
A:42       B:编译错误,应改为int c = (int) d/2;      C:43          D:应改为int c = int (d)/2;

很简单的一道题,考查基本数据类型知识的,double属于大类型,int小类型
这道题我选的答案是D,其实这道题我觉得我应该选的是B,没啥说的,可能脑子抽了,点了个莫名其妙的答案



14、 下面关于java中方法,描述错误的是( ) 反馈

A:定义一个方法时,如果该方法没有返回值,应该写void
B:定义一个方法之前要明确该方法需要的参数和返回值类型
C:方法可以提高代码复用性,提高程序运行的效率
D:方法只有调用才会被执行

这道题我选的是D,但是答案是C
讲实话,这一块的知识有点模糊,平时看到这种文字性的概念,随便扫扫就过去了,没有用心记
而且这道题认真思考的话,是完全选的出来的,单选题只有一个答案,首先看C,方法可以提高程序运行的效率,这句话是不对的,程序在调用方法时,还是一遍一遍的去读方法,写方法只是减少代码量,提高编写效率,并不是提高运行效率.


26、 下列方法定义中,正确的是( ) 反馈


A:int x( ){ return true; }


B:void x( ){ return true; }


C:int x( ){ char ch='a'; return (int)ch; }


D:int x( int a, int b){ return a+b; }


这道题我选择的答案是BCD,而正确答案是CD
这里我是犯了一个在错误,也是对平时的概念把握不牢靠,我以为返回值类型是void的话,
写不写return或者return后面跟什么都无所谓.但是很明显,返回true的话,返回值类型应
该是boolean类型.


以上是考试错掉的题目
进行了认真的分析..虽然错的都没什么技术含量,看来平时对概念的掌握还应该加强.







回复 使用道具 举报
继续加油哦   
回复 使用道具 举报
Day x
今天学习了面向对象的相关基础知识
面向对象的思想大概就是将身边的事物用编程的思想和方式表示出来
面向对象是基于面向过程的
面向过程相当于一件事情的执行者
而面向对象则相当于事情的指挥者
今天主要学习了java中的基本单位-类(class)的基本知识
用class来形容身边的事物
类的概念: 是一组相关的属性和行为的集合
对象:是该类事物的具体体现
而类中,含有成员变量和成员方法
举个例子就是 学生作为一个类
成员对象就是学生的属性,比如姓名,年龄等
而成员方法就是这个成员对象的功能,比如学习,休息等
成员变量不同于局部变量的地方有四点:
1,在类中的位置不同:成员变量在类中,方法外;而局部变量在方法中或者方法声明上
2,在内存中的位置不同:成员变量在堆内存;而局部变量在栈内存中
3,生命周期不同:成员变量随着对象的创建而创建,对象的消失而消失;而局部变量则跟随方法的调用和调用完毕存在和消失
4,初始值:成员变量有默认初始值,局部变量没有;
一些简单的代码练习:
//创建类
public class Phone {
   String pinpai;
   int price;
   String color;
   
   
   public void call(String name) {
      System.out.println(""+name+"打电话");
   }
   public void sendMessage(String name) {
      System.out.println(""+name+"发短信");
   }
}
//调用类
public class PhoneDemo {
   public static void main(String[] args) {
      Phone p = new Phone();
      System.out.println(p.pinpai);
      System.out.println(p.price);
      System.out.println(p.color);
      System.out.println("--------");
      p.pinpai = "iPhone";
      p.price = 8999;
      p.color = "黑色";
      System.out.println(p.pinpai);
      System.out.println(p.price);
      System.out.println(p.color);
      System.out.println("--------");
      p.call("fay");
      p.sendMessage("mikoto");
   }
}
第二个知识点      封装与私有关键字---private     与  关键字  this
private关键字:
a:是一个权限修饰符。
b:可以修饰成员(成员变量和成员方法)
c:被private修饰的成员只在本类中才能访问。
封装的意义:
       提高代码的安全性,不可被随意访问;
       提高代码的复用性:在其他类中调用使用后,不影响它本身的值;
Private的常见应用:把成员变量用private修饰,并提供相应的getXxx()/setXxx()方法
this关键字: this:代表所在类的对象引用,方法被哪个对象调用,this就代表那个对象
this在什么时候使用:在局部变量和成员变量重名的时候
接下来学习了构造方法
构造方法主要用来给创建的对象的初始值进行初始化
构造方法必须要与类名一致,没有返回值类型,没有void,没有具体返回值;
构造方法可以重载
系统有默认的构造方法
Public calss(){};
这里学习了两种构造方法,一种是无参构造和对应的set/get方法
第二种是比较常用的有参构造,即:
Public class (参数类型参数名,参数类型1 参数名1…..){
      this.成员变量 = 局部变量;
}
然后有一个知识点需要掌握,
类名作为返回值和类名作为参数名时
1,类名作为参数名时,
       学生类中有一个方法.打印一句话
       老师类中有一个方法,参数为学生类名,
       测试类需要在main方法中创建两个对应的对象,然后调用老师类的方法即可
2,类名作为参数名时,
       学生类中有一个方法,打印一句话
       老师类中有一个方法,返回值为学生类名,返回了学生类的地址值
       测试类需要在main方法中创建老师类的对象,通过老师类来得到学生类的对象,然后调用学生类的方法.
今天对于面向对象的学习感到了一些吃力,理解起来比较慢,对其概念感觉没有很理解清楚,需要下来加紧复习练习

回复 使用道具 举报
几天不见,进步贼大
回复 使用道具 举报
陈文老师 发表于 2018-1-23 09:03
几天不见,进步贼大

回复 使用道具 举报
day x
今天学习了API,String和StringBuilder
API就是应用程序编程接口
就是一些供我们使用的java类.


String类之前预科班有过简单学习,今天复习了一下方法的使用.


放几道练习题吧,比如这个反转字符串
public static String reverse(String s){
                String ss = "";
                for(int i=s.length()-1;i>=0;i--){
                        ss = ss+s.charAt(i);
                }
                return ss;
        }
这个方法用来返回反转后的字符串

还有一道,用了一些基础的方法,作为简单的练习吧
public class checkQQ {
   public static void main(String[] args) {
      Scannersc = new Scanner(System.in);
      System.out.println("请输入一个QQ号");
      Stringqq = sc.nextLine();
      if(checkqq(qq)){
          System.out.println("这是一个正确QQ号");
      }else{
          System.out.println("这不是一个正确QQ号");
      }
   }
   public static boolean checkqq(String a){
      if(a.length()<5||a.length()>12){
          return false;
      }else if (a.startsWith("0")) {
          return false;
      }else {
          return true;
      }
   }
}

String类因为之前预科班学到过,而且当时理解不深,所以后来仔细复习了,所以没有什么难点

StringBuilder类
StringBuilder:是一个可变的字符串。字符串缓冲区类。

String类和StringBuilder类的区别
String的值是固定的
而Stringbuilder的内容是可变的

这里是StringBuilder类的常用方法
A:构造方法:
     StringBuilder()
  B:成员方法:
     public int capacity():返回当前容量 (理论值)
     public int length():返回长度(已经存储的字符个数)
public StringBuilder append(任意类型):添加数据,并返回自身对象
public StringBuilder reverse():反转功能

还是放几道练习题吧
//1.      定义MainApp类,包含main()方法;
//2.      在MainApp类中,定义以下两个方法:
//1)      可以统计一个字符串中,某个字符出现的次数;
//public static int countChar(String str,char c)
//2)      可以统计一个字符串中,某个字符串出现的次数;
//public static int countString(String str,String s)
//3.      请实现方法,并在main()方法中分别调用这两个方法进行统计。

public class homework {
   public static void main(String[] args) {
      String str = "javajfiewjavajfiowfjavagkljjava";
      Stringstr1 = "j";
      Stringstr2 = "java";
      //1
      int numj = count(str, str1);
      System.out.println(numj);
      //2
      int numjava = count(str, str2);
      System.out.println(numjava);
   }
   public static int count(String str,String word){
      int count = 0;
      int a = 0;
      a = str.indexOf(word);
      if(a<word.length()){
          count++;
      }
      while(true){
          a = str.indexOf(word,a+word.length());
          if(a!=-1){
             count++;
          }
          if(a==-1){
             break;
          }
      }
      return count;
   }
}

这道题也可以不使用count++的形式来计算,可以改为用删减前的字符长度减去删减后的字符串长度,除去删减字符的长度
就可以得到删减的次数


今天的练习总体感觉不是很难,最近一直有一种很奇怪的感觉,自己啥也不会没弄明白,但是做题倒是也能做出来,感觉很迷

可能还是因为概念把握不清楚的原因




回复 使用道具 举报
希望你们越来越好!
回复 使用道具 举报
学无止境   路还很长  加油哦  
回复 使用道具 举报
回复 使用道具 举报
Day 09
今天主要学习了对象数组和ArrayList类
对象数组呢 我的理解就是数组是引用数据类型,元素为一个类的对象的数组
练习就是创建学生类,然后建立个学生数组,运用所学进行数组的操作
没什么难度~
主要是学习了ArrayList类
目前学过的内容中,涉及到容器这个概念的就只有数组和StringBuilder
然后今天学的这个类也是一个容器,叫做集合类
因为StringBuilder的返回值只能是一个String类型的值,所以很多情况并不适合使用
数组呢,在定义和使用是,它的长度都是固定的,所以也显得不是很方便
所以  集合  这个类就显得非常重要了
集合类的构造
ArrayList<String> array = new ArrayList<String>();
这里面的String可以换为其他的引用数据类型
这里有几个集合类的方法可供使用
public E get(intindex):返回指定索引处的元素
public int size():返回集合中的元素的个数
public booleanremove(Object o):删除指定的元素,返回删除是否成功
public E remove(intindex):删除指定索引处的元素,返回被删除的元素
public E set(int index,E element):修改指定索引处的元素,返回被修改的元素
放个练习题
public class Arraylist_Ex {
   public static void main(String[] args) {
     //统计所有字符个数,并把所有索引为偶数的元素改为全大写
     ArrayList<String> list = new ArrayList<String>();
      list.add("hello");
      list.add("java");
      list.add("world");
      int sum = 0;
      for(int i=0;i<list.size();i++){
          String str = list.get(i);
          int a = str.length();
          sum = sum+a;
      }
      System.out.println("长度为:"+sum);
      for(int i=0;i<list.size();i++){
          if(i%2==0){
             String str = list.get(i);
             str = str.toUpperCase();
             list.set(i, str);
          }
      }
      System.out.println(list);
   }
}
接下来是集合类的遍历
这里的遍历就和之前学过的遍历非常像了,也是进行循环,取得集合中的每个值
public static void main(String[] args) {
      ArrayList<String> array = newArrayList<String>();
      array.add("hello");
      array.add("world");
      array.add("java");
for(int x=0;x<array.size(); x++) {
          String s = array.get(x);
          System.out.println(s);
      }
   }
在最后综合了今天和之前所有的所学知识,编写了学生管理系统
然后我放一下我的代码截图吧
还算做的满意,没有太多磕磕绊绊

回复 使用道具 举报
Day 10
今天学习了IO流和FileWriter类的使用
IO流呢,主要是用来处理设备之间的数据传递
在java中,操作流的类都在IO包中
今天学习了输入流和输出流
这里就讲到了FileWriter
主要学习了利用FileWriter向文件中写入和读取数据
首先构造方法:
FileWriter(StringfileName)传入文件的路径
(两种文件路径)
1,绝对路径,就是带盘符,详细的文件地址
2,相对路径,创建在工程目录下,不需要写详细的地址
成员方法:
void write(String str) 向文件中写str
void flush()  将内存中的数据刷新到文件中
void close()  关流释放系统底层资源
void write(String str):写一个字符串
void write(String str,intindex,int len):写一个字符串,index开始,长度为len;
void write(intchar):可以写字符,也可以写字符对应的int
void write(char[] ch):写一个字符数组数据
void write(char[] chs,intindex,int len):写一个字符数组的一部分数据
这里有几点注意事项
追加和各个系统所识别的回车符
1,追加录入
FileWriterfw = new FileWriter("a.txt",true);//表示在指定文件中进行追加写入,默认值为false,改为true即可追加
2,回车符:在Windows系统下只识别\r\n;
                  在linux系统下识别\r
                  在mac系统下识别\n
接下来学习了FileReader类的使用
其实大体和FileWrite差不多,只是这个类是用来读取数据的,Write是用来录入的
结合了FileWriteFileReader,我们可以实现比如从文档中读取数据,进行修改,再录入文档的基本操作
放一些练习的代码吧
这个是用输入和输出功能实现的复制文本功能,用的是一次复制一个字符的方式
public static void main(String[] args) throws IOException {
      FileReader fr = new FileReader("firstday.java");
      FileWriter fW = new FileWriter("copy.txt");
      int ch;
      while ((ch=fr.read())!=-1) {
          fW.write(ch);
      }
      
      fW.close();
      fr.close();
      
   }
而这个用的是一次复制1024个字符的方式,选用1024是配合容量进制
public static void main(String[] args) throws IOException {
      FileReader fr = new FileReader("firstday.java");
      FileWriter fw = new FileWriter("copy2");
      char[] ch = new char[1024];//1024
      int len;
      while((len=fr.read(ch))!=-1){
          fw.write(ch, 0, len);
      }
      fw.close();
      fr.close();
   }
创建对象以后注意抛出异常,经常报错找不到错在哪里,一开始总忘记抛出异常
接下来学习了缓冲流的使用
说实话,没有很搞明白缓冲流的概念,不知道缓冲流的主要思想
只是知道它的效率比较高,而且是主流用法,以后也会经常用到..


回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马