黑马程序员技术交流社区

标题: 学习javaEE的经历 [打印本页]

作者: Zhouzihao1996 时间: 2019-3-11 22:35
标题: 学习javaEE的经历
语言：人与人交流沟通的表达方式
计算机语言：人与计算机之间进行信息交流沟通的一种特殊语言
Java语言是美国Sun公司（Stanford University Network）在1995年推出的计算机语言
Java之父：詹姆斯·高斯林（James Gosling）
2009年，Sun公司被甲骨文公司收购

JDK  java开发工具包
JRE  java运行环境
JVM  java虚拟机

JDK > JRE > JVM

   编写源代码
结尾：.java
   编译代码
   命令： javac 代码.java
   编译会生成一个代码.class的二进制文件
   运行代码
   命令： java  代码

java基础语法****

注释：解释说明代码的功能  不参加运行

单行注释：  //
多行注释： /*多行注释*/

关键字：

   被java赋予特殊含义的单词
   特点：都是小写字母
   注意：以及被java使用了我们不能定义成其他的内容了


常量：在运行期间值不能发生改变的量

字符串常量  "双引号括起来的内容称之为字符串"

整数常量： 1 2 35555  666666 9999999

小数常量： 3.14

字符常量： '1'  'A'  '3'

布尔常量： true  false

空常量： null

数据类型:

字符串

   整数： byte short int long
   浮点数：  float double
   字符型：  char
   布尔型： boolean

      byte 范围： -128~127
int  范围： 2的31次方大概值 21亿
char 范围： 65535

      整数默认类型是 int
浮点数默认的类型是 double

变量：

   定义格式：

            数据类型变量名 = 数据值; int num = 98;
   数据类型变量名; 变量名 = 数据值; int  num; num = 60;

   变量使用的注意事项：
      1.变量名不能重复
   2.变量要给初始值否则不能使用
   3.long类型定义的时候值加上 L （默认类型 int）
   4.float类型默认的类型是 double 类型后面加上F 表示float

标识符：见名知意

   组成：数字字母下划线 _ [美元符 $ 能不用则不用]
   不能以数字开头
   不能是关键字

   小驼峰命名：首字母小写其他每个单词的首字母大写  firstName 主要用在方法名  变量名
   大驼峰命名：每个单词的首字母大写 FirstName    类

数据类型转换：

   自动类型转换：从数据范围小的数据类型转换成数据范围大的数据类型  不需要我们操作

      强制类型转换：从数据范围大的数据类型转换成数据范围小的数据类型
               出现问题：精度丢失  数据溢出

      算数运算符：
   + - *

   '/'  整除使用的两个整数相除结果还是整数

   %  取模（取余数）一般只针对整数才有效果

   两个数据类型进行运算结果类型是数据范围较大的一方

   +操作：

   byte short char 进行运算的时候把提升成int类型再进行计算
错误的案例：
   /* byte num1 = 3;
      short num2= 30;
      short num3 = num1 + num2;

   */

   字符串的+操作：
      字符串的拼接（字符串可以使用+号拼接任意类型的数据）
   注意：拼接顺序从左到右
   8+80+"hehe"+1
   "hehe"+80+90

赋值运算符：
      int num = 10;  num += 10; ==> num = num +10;

byte num1 = 2;
byte num1 = num1+1;//出现问题最终的结果是int类型
byte num1 +=1; //相当于 byte num1 = (byte)(num1+1);

   int num = 10;  num %= 2; ==>num = num%2;

/* int a = 10;  //雪碧
      int b = 20;  //可乐
      System.out.println("a:" + a);
      System.out.println("b:" + b);

   int temp = a;//空杯子
      a = b;
      b = temp;
      System.out.println("a:" + a);
      System.out.println("b:" + b);*/

自增自减：
   最多的用的地方单独使用：前++ 和后++ 效果一样
   如果不是单独使用：
         ++前  先加1 再进行运算
   后++  先使用再加1

关系运算符：
      得到的结果都是布尔类型的；
      > <  >=  <=    ==  !=
      符号都是英文状态下
      >= ,<= 满足任意一个条件 > 或者是等于返回值为 true
!= 返回值只有在不相等的情况下返回 true

逻辑运算符：

   &  逻辑与只有全部为 true 结果才为 true 其他为 false
   |  逻辑或只有全部为 false 结果才为 false 其他都为 true
   ^  逻辑异或相同为 false 不同为 true
   !  逻辑非  true  !true  ==> false


   && 短路与  遇到第一个为 false 的值之后将不在执行后面的内容
   || 短路或  遇到第一个为 true 的值之后将不在执行后面的内容

/*
   int i1 = 5;
      boolean result = (i1++ > 5) && (++i1 > 4);
      System.out.println(result);//false
      System.out.println(i1); // 6

int i2 = 5;
      boolean result = (i2++ > 5) || (++i2 > 4);
      System.out.println(result);//true
      System.out.println(i2); //7
*/

三元运算符：

   关系表达式 ? 表达式1:表达式2;

   执行流程：执行关系表达式返回值 true 执行表达式1 否则执行表达式2
   int a=10;
   int b =20;
   a > b ? a:b;

键盘输入：
         导包：    import java.util.Scanner;
   创建对象：  Scanner scanner = new Scanner(System.in);
   接受数据：  int x = sc.nextInt();

   流程控制语句：

      顺序结构：从上往下依次执行；
      分支结构： if 语句
      if(关系表达式){
语句体;
   }
      关系表达式结果如果是 true 语句体执行否则不执行

   if语句的标准格式：
   if(关系表达式){
语句体1;
   }else{
语句体2;
   }
先执行关系表达式，如果表达式结果为 true 执行语句体1 否则执行语句体2

转换成三元运算符

if语句的扩展格式：
      if(关系表达式1){
语句体1;
   }else if(关系表达式2){
语句体2;
   ...

   }else{
语句体n;
   }

   先执行关系表达式执行到第一个符合条件的表达式执行其对应的方法体
   多者选其一

   输入一个数据：
   判断属于大写字母，小写字母，数字

   switch 语句：

switch(表达式){
case 值1:
   语句体1;
   // break;
case 值2:
   语句体2;
   break;
case 值3:
   语句体3;
   break;
   ...

default:
   语句体;
   break;

}

switch语句的注意点：
   1.表达式的内容： byte short int char  枚举  String
   2.case 穿透如果case语句后面没有跟 break 会继续执行下一个选项的内容直到遇到第一个 break为止
   3.case语句顺序没有要求 default 可以任意放置但是写上 break ；
   4.case 值不能重复

switch 语句和 if..else 扩展格式区别：
   最大的区别：  switch 效率高占内存 if...else 效率低灵活性高

for 循环：

①初始化语句    在程序开始的时候会执行一次
②条件判断语句
③ 循环体
④ 步进语句

   格式：
      for (①初始化语句;②条件判断语句;④ 步进语句  ){
      ③ 循环体;
   }

   ①->②->③->④->②->③->④->②...

      结束：②条件判断语句返回值为false 停止循环

逢7过（统计过的个数）代码：
   /*
      int count = 0;

      for (int i = 1; i < 100; i++) {
         // 是7的倍数
         //个位或者是十位为7
         int ge = i % 10;
         int shi = i / 10;

         if (i % 7 == 0 || (ge == 7 || shi == 7)) {

            System.out.println(i);
            count++;
         }
      }
      System.out.println("count:" + count);
   */


while 循环格式：

   ①初始化语句
   while(②条件判断语句){
   ③ 循环体
   ④ 步进语句
   }

   ①->②->③->④->②->③->④->②...

   结束：②条件判断语句返回值为false 停止循环


do .. while 循环：

      ①初始化语句
   do {
   ③ 循环体
   ④ 步进语句
   }while(②条件判断语句);

   ①->③->④->②->③->④->②...

   结束：②条件判断语句返回值为false 停止循环
   特点：第一次执行无论条件判断为true或者false 都会先执行一次

三种循环的区别：

   do...while 无论条件是否成立都会执行一次
   for 循环使用明确循环次数
   while 循环不明确循环次数

   如果死循环用 while(true){ 循环体}

continue 作用跳过某一次循环后面的内容继续执行

break 为终止当前的循环后面的内容不再继续执行


   Random random = new Random();
   int i =random.nextInt(10);// 随机出 0-10之间的数据  包括0 不包括10

   获取指定范围的数据  90-100 包含90和100 random.nextInt(100-90+1)+ 90;

快捷键
ALT + ENTER  遇到代码有问题直接使用这个组合键

数组：
变量  数据类型变量名 = 值;

存储多个相同数据类型的元素

   int[] arr;
   数据类型 [] 数组名;

数组的动态初始化：只要有数组的长度和数据类型就可以创建
   格式：

   数据类型 [] 数组名 =  new 数据类型[数组长度];
          int [] arr  =  new  int[10];

数组元素访问的格式：
      数组名[索引];

arr[0]; //第一个元素

索引元素在数组中的编号从0开始

系统默认的根数据类型给相关的默认值

给数组元素赋值：

         数组名[索引] = 数据值;

静态初始化：
      需要知道数组的内容

      数据类型 [] 数组名 =  new 数据类型[]{元素1,元素2,元素3,...};
         int [] arr = new int[]{1,3,6,7,8,9,0};

      静态的省略格式：(进行操作的时候也有new的这个步骤)
         数据类型 [] 数组名 =  {元素1,元素2,元素3,...};
         int [] arr = {1,2,4,5,6};

      基本数据类型  4类8种
      引用数据类型默认值就是 null

异常：

   NullPointerException  空指针异常
         数组的值变成 null 要访问数组里面的元素

   ArrayIndexOutOfBoundsException  数组索引超出界限异常
      数组的索引超出了数组的范围

遍历：
      如何求出数组的长度：
         arr.length;

for(int i= 0;i<arr.length;i++){
System.out.println(arr[i]);
}
方法：
方法只有存在才能使用
方法创建好了不会直接运行需要手动调用才能运行

基础方法的定义格式：
   public static void 方法名(){

   方法体;
   }

基础方法的调用格式：
         方法名();

带参数的方法的定义格式：

   public static void 方法名(参数类型参数名1,参数类型参数名2,参数类型参数名3,...){
   方法体;
   }

带参数的方法的定义格式：
         方法名(值1,值2,值3,值4.....);

参数对于方法来讲增加了方法的灵活性

形参  形式上的参数    方法定义时使用
实参  实际传递的参数方法调用的时候使用

带参数带返回值的方法的定义格式：

      public static 返回值类型方法名(参数列表){

   方法体;
[return 数据值;] //如果返回值是void 不需要这句
   }

返回值类型  void 表示什么都不返回
            其他：可以是任意的数据类型

            需要写上  return 数据值;

方法的注意事项：
      1.方法不能嵌套定义
2.返回值 void 不能写 return 值;  void后面可以跟 return; 但能return后面不能再写具体的值
   return 表示返回方法执行到此处后结束
   如果不是 void  必须得写上 return 值;
      3.方法的调用三种  单独调用  赋值调用（最常用的）打印调用
   CTRL + ALT + V 方法的返回值自动帮我们生成

定义一个方法的要求：

      1.返回值类型必须得明确
2.参数列表必须明确

建议：写方法的时候最好是能把方法的具体功能写上

方法重载：

      1.必须在同一个类中
      2.方法名要求必须相同参列表不同
               参数列表不同  1.数据类型不同  2.参数数量不同 3.多个参数的先后顺序不一样

      方法重载和什么没有关系：
            1.返回值类型无关
   2.和参数名称无关


基本数据类型作为方法的参数传递的是变量的值
引用数据类型作为方法的参数传递的是地址值
Debug过程:
1.打断点鼠标左键点击需要断点的位置
2.以debug模式运行
3.查看debug模式下各个变量的值
4.  step over 下一步 step into 进入方法里面

基础回顾:
   if
   单if语句  符合条件才会执行
   if..else 标准格式两者选其一
   if..else if..else...  扩展格式  多者选其一

switch:
      switch(表达式){
case 值1:
   语句体;
   //break;
case 值2:
   语句体;
   break;

default:
   语句体;
   break;
}
表达式的类型: byte short int char  枚举enum  String
   case后面值不能重复
   case 穿透: case语句后面的break丢失会造成继续执行下一个语句体
   case 语句先后顺序是可以颠倒的

逢七过:改  要求把剩余的数据按照每行5个进行排列打印出
/*
   public static void main(String[] args) {
int count = 0;
for (int x = 1; x <= 100; x++) {
//根据规则，用if语句实现数据的判断：要么个位是7，要么十位是7，要么能够被7整除
if (x % 10 == 7 || x / 10 % 10 == 7 || x % 7 == 0) {
continue;
} else {
count++;
if (count % 5 == 0) {
System.out.println(x);

} else {
System.out.print(x + "\t");
}

}
}

System.out.println("count:"+count);
}
*/
判断一个数据是否是质数:
   /*
   public static boolean isZhi(int num) {

for (int i = 2; i <= num; i++) {
if (i != num && num % i == 0) {
return false;
} else if (i == num) {

return true;
}

}

return false;
}
*/

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2