day1

作为小白
1今天刚刚学习了eclipse的基本使用操作 包括一些快捷键
认识到了注释的重要性
一 注释可以用来帮助理解代码
二 注释而已帮助修改代码错误  比如不确定某一块的代码的正确  可以分批注释来检测


2学习了java的基础语法  比如
public class firstday{
public static void main（String[] args）{
      System.out.println("Hello world!!");
}
}
这是入门级语句   我也算会hello world的萌新了


3学习了基本的数据类型
一共有8种数据类型
根据分类分为   整型  浮点型  字符型  布尔型
整型有          byte short int long 四种
浮点型有      float  double  两种
字符型有      char  一种
布尔型有      boolean 一种
并且学习了它们分别占多少字节和表示多大范围

然后今天也做了一下课上的练习





希望每天都能够消化掉所学的知识   大家一起进步

day2
今天学习了 运算符和if语句


常用运算符分类
算数运算符、赋值运算符、关系运算符、逻辑运算符、三元运算符
算数运算符：+，-，*，/，%，++，--
赋值运算符：=，+=，-=，*=，/=，%=
关系运算符：==，！=，<，<=，>，>=
逻辑运算符：&，|，^，！，&&，||


其中我认为比较不太好理解的是自增自减和&&||与&|的区别


int n1 = 10;
int n2 = n1++ + ++ n1 + --n1;//10+12+11=33



&逻辑与:有false则false。
      |逻辑或:有true则true。
      ^逻辑异或:相同为false，不同为true。

      !逻辑非:非false则true，非true则false。

这里引用一下斌哥的讲解

//&& ,|| 和& ,|的区别
       //首先 他们的结果肯定都是一样的  && || 有短路效果
       //&& 在左边结果为false的情况下  不执行右边的代码
       //|| 在左边结果为true 的情况下  不执行右边的代码

三元运算符的格式
（关系表达式）？表达式1：表达式2；
如果括号内条件为true,运算后的结果为 表达式1
如果括号内条件为false，运算后结果为 表达式2

// 如果我有3个数 i a b 现在要把最大的这个数 给另外一个变量e
       int temp =(a>b)?a:b;//獲取了ab 之间的最大值
       int e = (temp>i)?temp:i;//在和最后一个值比较得到最大值
      这里是第一种 用另一个中间量比较

          int e = (((a>b)?a:b)>i)?((a>b)?a:b):i;这里是第二种，嵌套形式

       System.out.println(e);

if 语句

if语句的第一种格式：if（关系表达式）{语句体}
if语句的第二种格式：if(关系表达式){
                                        语句体1
                                  }else{
                                        语句体2
                                  }
if语句的第三种格式：
                                if（关系表达式1）{
                                         语句体1
                                 }if else （关系表达式2）{
                                         语句体2
                                 }。。。
                                  else{
                                         语句体n+1
                                 }



这里有一道课上的练习题
//4 现在有  a b c三个int变量  要求把abc 按照从大到小的顺序输出
       int aa = 12;
       int bb = 11;
       int cc = 13;
       int max = ((aa>bb)?aa:bb) >cc ? ((aa>bb)?aa:bb):cc;
       int min = ((aa<bb)?aa:bb) <cc ? ((aa<bb)?aa:bb):cc;
       int mid = aa+bb+cc - max - min;
      
       System.out.println("他们的顺序是: "+ max +" "+ mid+" "+min);

这是斌哥的解法，这种倒是可以解出来
但是我有个小问题，如果把条件改为很多变量怎么算，总和减去最大最小和的方法就不行了。。。

以后可以返回来再看看，或许会有更好的解法，现在还没想清楚其他算法。

这是课上做的练习题

day 3今天学习了 3种循环语句 for while 和   do...while
第一种for语句  格式如下
for(初始化语句;判断条件语句;控制条件语句) {

        循环体语句;

}

举个例子 //求出1-100累加之和

int a ；

int sum=0;

for（a=1;a<=100;a++）{

              sum = sum + a;

}

System.out.println(sum);//这里要注意，打印指令写在循环内的话，会输出每次循环的结果，而写在循环外的话，则只会输出最后循环结束的结果。

第二种 while语句   格式如下

while（判断条件语句）{

            循环体语句；

}

//while语句中只写判断条件语句，所以控制条件可以写在外面。

//另外，while语句用来写无限循环在方便不过了，例如无限向控制台输出某个信息

int a = 0；

while（true）{

          a++；

System.out.println(a);

}

这里将会无限循环a++

第三种循环   do...while循环   格式如下

do{

          循环语句体；

}while（判断条件语句）；

还拿从1一直加到100举例

int a ;

int a = 0;

                int sum = 0;

                do {

                        sum = sum + a;

                        a++;

                } while (a<=100);

                System.out.println(sum);

然后是学习了循环控制语句

控制跳转语句break

break的使用场景：

在选择结构switch中

在循环语句中

break的作用：跳出单层循环

控制跳转语句continue

continue的作用退出单次循环

然后学习了for语句的嵌套使用

例如  打印九九乘法表

for(int i=1;i<10;i++){

    for(int j=1;j<10;j++){

system.out.println(j+"x"+i+"="+i*j);

     }

system.out.println();

}

最后学习了Random类的使用 和 Scanner对象的创建和使用

Random是用来创建一个随机数的类

它的使用步骤：

1导包            inport java.util.Random;

2创建对象     Random random = new Random();

3获取随机数  int number = random.nextInt(x)；//这里的括号就是值域了，默认从0开始到x-1

Scanner键盘录入

1导包            import java.util.Scanner;

2创建对象     Scanner.scanner = new Scanner(system.in);

3接收数据     int number = scanner.nextInt();

最后做了一下课下的3个练习

day4
今天是在预科班学习的最后一天
今天学习了String类  String类代表字符串,在java中所有字符串的字面值都是用它来实现
字符串有几点需要注意


1,字符串的字面值也可以看成是一个字符串对象
2,字符串是常量,一旦被赋值,就不能被改变
3,字符串本质是一个字符数组


String类的常用构造方法
String string = new String("第一种");
String string2 = "第二种";


这里要注意
通过构造方法创建的字符串对象和直接赋值方法创建的字符串对象的不同
构造方法创建的字符串对象是存放在堆内存
而直接赋值创建的字符串对象是存放在常量池中




String类的判断功能
boolean equals(Object obj):比较字符串的内容是否相同

boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写

boolean startsWith(String str):判断字符串对象是否以指定的str开头

booleanendsWith(String str):判断字符串对象是否以指定的str结尾

String类的获取方法
int length():获取字符串长度
char charAt(int index):获取指定索引处的字符
int indexof(String str):获取str在字符串对象中 第一次出现的索引
string substring(int start):从start开始截取字符
string substring(int start,int end)从start开始(含),到end结束截取中间字符


String类的转换功能

char[] toCharArray():把字符串转换为字符数组

String toLowerCase():把字符串转换为小写字符串

String toUpperCase():把字符串转换为大写字符串


//这里是课上做的小练习
public static void main(String[] args) {
                // 模拟登陆,一共三次机会,并提示还有几次
                String username = "itheima";
                String password = "123456";
                Scanner scanner = new Scanner(System.in);
               
                int count = 1;
                while(count<=3){
                        System.out.println("请输入用户名");
                        String username1 = scanner.nextLine();
                        System.out.println("请输入密码");
                        String password1 = scanner.nextLine();
                        if(username.equals(username1)&&password.equals(password1)){
                                System.out.println("登陆成功");
                                break;
                        }else{
                                System.out.println("登录失败");
                                count++;
                                if(count<4){
                                        System.out.println("您还可以输入"+(4-count)+"次");
                                       
                                }else{
                                        System.out.println("没有尝试次数了");
                                }
                        }
                }
        }








//小练习2
public static void main(String[] args) {
                // 统计一串字符串当中大写字母字符,小写字母字符和数字的出现次数
                String str = "abcdef12345ABCD";
                int A = 0;
                int a = 0;
                int num = 0;
               
                for(int i=0;i<str.length();i++){
                        char ch = str.charAt(i);
                        System.out.println(i);
                        if(ch>='A'&&ch<='Z'){
                                A++;
                        }
                        if(ch>='a'&&ch<='z'){
                                a++;
                        }
                        if(ch>='0'&&ch<='9'){
                                num++;
                        }
                }
                System.out.println("大写有"+A);
                System.out.println("小写有"+a);
                System.out.println("数字有"+num);
               

        }





总结
在预科班学习的时间过得很快,今天已经是最后一天的课程了
从刚开始比较松散的学习状态已经过渡到了身心投入的学习状态当中
每天能够坚持课上认真听讲,课下积极复习

虽然平时也有理解较慢的地方,但是在斌哥和周围同学的帮助下还是能很好的解决问题
现在回顾一下这短短几天时间,对自己的表现还是比较满意
希望能够在接下来的日子里踏踏实实 认真的走完每一步
希望能够在黑马学习的日子里不留下遗憾
也希望能够大家能够一起进步,通过在这里的学习,使自己的未来变得更加辉煌

几天前预科班结束

斌哥留的六道题里面有道题困扰了我很久

在一位不愿意透漏姓名的同桌的讲解下

终于弄懂了

然后放一下原题

//4.编写一个程序，将下面的一段文本中的各个单词的字母顺序翻转，

//  “To be or not tobe"，将变成"oT ebro ton ot eb"

         String string = "To be or not to be";//定义一个字符串

      String[] split = string.split(" ");//将string按空格分割

      String last = "";//定义最后要输出的字符串

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

          String string2 = split[i];//用string2遍历split

          char[] ch = string2.toCharArray();//用ch获取到每个字符

          String string3 = "";

          for(int j=ch.length;j>0;j--){//翻转

             string3 = string3 + ch[j-1];//用string3获取翻转后的字符串

          }

          last = last + string3 + " ";//拼接string3

      }

      System.out.println(last);

然后今天是基础班的正式上课

今天主要是回顾了一下预科班之前的内容

在源哥风趣的授课风格之下

我们温习了helloworld 的写法并浅析了再次安装jdk的知识

开个玩笑

今天了解到了java的发展历史和java语言平台

并学习了jvm,jre和jdk的关系

学习了dos命令和如何在控制台中编译和运行java程序

虽然今天是复习但是还是学到了新的知识点

今天通过视频教学,详细了解到了类型转换中强制转换的弊端

并且在syso向控制台输出字符”字符”中,学习到了一个新的命令

\r\n  ==  回车       \t == tab键

是非常有用的小命令

今天就这样希望能在接下来的学习中保持动力

和同学们一起进步

数着数着也不知道Day几了
今天是基础班第二天
依旧是复习预科班的知识
今天复习了各种运算符
着重讲了一下自增自减
这一块知识在预科班的时候自己没有理解的很透彻
今天也是很好的巩固了


另外 今天还复习了键盘录入
复习一下步骤

Scanner键盘录入

1导包            import java.util.Scanner;

2创建对象     Scanner.scanner = new Scanner(system.in);

3接收数据     int number = scanner.nextInt();

下面是今天的课后作业截图

Day x
今天第一天自习
进入基础班已经两天时间了
认真回想了一下自己学过的知识
补充了笔记
另外今天轮到我演讲
结合数组和之前学到的for循环
做了一个简单的事例,放张图


另外自己预习了一下方法这一部分的知识
简单的做了下总结





今天自己预习的效果还可以 希望可以保持

Day X

今天复习了选择流程控制语句和循环流程控制语句

选择语句主要讲了if语句和switch语句

If语句和switch语句的用法还是有很大的区别

我自己感觉switch语句的局限性有很多,比如表达式的取值,只有byte,short,int,char四种类型

但是switch在JDK5以后可以用枚举,在JDK7以后可以用String了.

而if语句呢感觉比较灵活,在处理较多数据时,还是if好用一些.

因为switch语句中 case后面跟的是固定的值,这样一来提高了很大的代码量.

然后是复习了循环流程控制语句

循环流程控制语句主要有三种,for循环,while循环和do…while循环

我之前在for循环这一块内容学习的不是很扎实

今天源哥带我又复习一遍,感觉美滋滋

坐了几道题,先看一下

public class homework {

     public static void main(String[] args) {

          Scanner scanner = new Scanner(System.in);

          int count = 0;

          System.out.println("请输入学员总人数:");

          int total = scanner.nextInt();

          for(int i=1;i<=total;i++){

               System.out.println("依次输入学员们的成绩");

               int score = scanner.nextInt();

               if(score>=80){

                    count++;

               }else{

                    continue;

               }

          }

          double rate = (double) count/total; //直接在这里拿来两个值,做完运算又变int了,拿着0去输出

          System.out.println(rate);

     }

}

          第二题 关于while的用法

public static void main(String[] args) {

     //珠峰8848,纸0.001

     //对折多少次高度超过珠峰

     int mount = 8848000;

            int paper = 1;

            int count = 0;

            while(true){               //这里直接拿纸控制也行,为了用一下无限循环

                  paper *= 2;

                  count++;

                  if(paper>=mount){

                       break;

                  }

            }

System.out.println(count);

      }

     

第三个练习

import java.util.Scanner;

public class asd {

     public static void main(String[] args) {

          /*  1.功能描述：模拟计算器功能，对键盘录入的两个int类型的数据进行加、减、乘、除的运算，并打印运算结果

               2.要求：

                    (1)键盘录入三个整数,其中前两个整数代表参加运算的数据，

                    第三个整数为要进行的运算(0:表示加法运算,1:表示减法运算,2:表示乘法运算,3:表示除法运算)

                    (2)使用今天所学知识完成功能

                    (3)演示格式如下:

                         请输入第一个整数:30

                         请输入第二个整数:40

                         请输入您要进行的运算:+

                         控制台输出:30+40=70

           */

          Scanner scanner = new Scanner(System.in);

          System.out.println("请输入第一个整数:");

          int a = scanner.nextInt();

          System.out.println("请输入你要进行的操作(+,-,*,/)");

          String ch = scanner.next ();//如果要用比较字符串的方法来确定运算方式,最好用.next的方式,不然控制台非常容易出bug

          System.out.println("请输入第二个整数:");

          int b = scanner.nextInt();

          String jia = "+";

          String jian = "-";

          String cheng = "*";

          String chu = "/";

          if(ch.equals(jia)){

               int sum = a+b;

               System.out.println(a+"+"+b+"="+sum);

          }

          if(ch.equals(jian)){

               int cha = a-b;

               System.out.println(a+"-"+b+"="+cha);

          }

          if(ch.equals(cheng)){

               int ji = a*b;

               System.out.println(a+"*"+b+"="+ji);

          }

          if(ch.equals(chu)){

               double shang = a/b;

               System.out.println(a+"/"+b+"="+shang);

          }

     }

}

接下来学习了控制跳转语句

主要就是break和continue;

区别在于 break是跳出整个循环,而continue只是跳过这一次的循环.

今天的内容就是这些,定期复习有助于更好的掌握知识~

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);

      }

   }

在最后综合了今天和之前所有的所学知识,编写了学生管理系统

然后我放一下我的代码截图吧

还算做的满意,没有太多磕磕绊绊