黑马程序员技术交流社区

标题: 课程知识梳理 [打印本页]

作者: 杨建辉 时间: 2019-5-25 16:54
标题: 课程知识梳理
javaEE 企业版    主要从事的工作：企业级别的应用网站大数据处理    C语言  JNI  java    python 胶水语言
javaSE 标准版本 GUI
javaME  嵌入式的内容  Android kotlin

计算机两个最牛的人物
Alan·图灵计算机的思想  CPU 计算流程控制
冯诺依曼计算机使用二进制  匈牙利布达佩斯

  .class 要执行的话依赖 JVM 虚拟机

   windows .exe
   mac    .dmg
   linux  Ubantu CentOS RedHat

**** JDK包括 JRE 和开发工具
   JRE包括 JVM 和核心类库

为什么要配置path环境变量？
   为了在电脑的任意目录下都可以对java代码进行编译和运行
怎样配置path环境变量
   我的电脑  右键选择属性 -->高级环境设置--》环境变量 --》在系统变量里面创建一个JAVA_HOME -->配置Path

java -version //查看当前的java的版本

DOS命令：
   1.切换盘符盘符: D:
   2.打开目录 cd 目录 cd 目录1\目录2..
   3.回到上一个目录 cd .. cd \
   4.查看当前目录的所有的文件  dir
   5.清屏 cls
   6.退出 exit


win + E  直接打开我的电脑

public class HelloWorld{/*这个也是多行注释*/

public static void main(String[] args){  // JVM原理

System.out.println("hello 无论怎么写 world");

}

}
java程序编译命令： javac  文件名.java  得到一个.class 文件
java程序运行命令:  java  文件名

所有的java的符号全部都是英文状态下的 subline 64G

注释：解释说明代码的功能
   不参与程序的运行

   1.单行注释  //这个是单行注释
   2.多行注释  /*这个是多行注释*/

  关键字：  已经被java语言使用的个别的有特殊含义的单词  我们以后不能再使用
   特点：都是小写的字母组成的单词在编辑器里面有特殊的颜色

常量：在程序运行的期间值不会发生变化的量

   字符串常量：  "两个双引号之间的数据都称之为字符串常量"
   字符常量：  在两个单引号中间有且仅有一个符号不能没有任何内容  ' ' 'A' '5' '国' //错误的写法 '中国'  ‘0’
   整数常量：  包括正数和负数还有0
   浮点数常量：  3.14 -5.18
   布尔常量：  true  false
      空常量：  null

常用的基本的数据类型：
      整型：    byte 占1个字节（-128~127） short 占2个字节    int 默认占4个字节  21亿       long 占8个字节
   浮点型：    float 占4个字节          double 默认占8个字节 3.14  3.1399999999
   字符型：    char    占2个字节  范围 0-65535
   布尔型：    boolean    占1个字节  true  或者  false

变量的定义格式：
         硬盘    内存    缓存（寄存器） IO流，GC 木桶原理

   数据类型  变量名  =  数据值/常量值


   变量的使用：
      1.变量名不能重复
2.使用变量前一定要给变量赋值
3.如果定义long类型的数据数据后面加上L    long l = 10000000000L;
   如果是使用 float 类型 float f = 3.14F; double 默认

   标识符命名规范：
      组成部分： 26个英文字母数字0-9 下划线 _  美元符号$
硬性要求：不能以数字开头

      小驼峰命名：变量和方法
            规范：首字母小写其余的每个单词的首字母大写 firstName

大驼峰命名：类接口
      规范：首字母大写其余的每个单词的首字母大写 FirstName  HelloWorld

数据类型转换：
   1.自动类型转换    long l = 100; 等号的左边的数据类型的范围大于等号右边的数据的范围
   2.强制类型转换    float f = 3.14F; 等号的左边的数据类型的范围小于等号右边的数据的范围
      强制类型转换出现的问题：  1.精度损失    int num = (int)88.88; //88
                           2.数据溢出  数据不准确

   自动类型转换不需要我们操作而强制类型转换建议最好不要使用
switch 语句：

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

case 常量值2:
   语句体2;
   break;


case 常量值3:
   语句体3;
   break;

   default:
   语句体n;
   // break;

   }

   表达式能放那些类型的数据： byte short int char  String enum(枚举)

for循环：
   组成部分：
         ①初始化语句    只是在循环开始执行一次
   ②条件判断    判断符合条件循环继续执行
   ③循环体
   ④步进语句/条件控制

格式：
   for(①初始化语句;②条件判断;④步进语句/条件控制 ){
   ③循环体
   }
   int sum = 0;
   for(int i = 1; i<=100; i++ )
               //偶数
         if(i%2==0){

   sum += i;

   }
   }
   //一百内所有的能被6整除的数据的和是多少？
   int sum =0;
   for(int i= 1;i<=100;i++){
   //被6整除
   if(i%3==0 && i%5==0){
   sum+=i;
   }
   }


      水仙花  Water Fresh Flower

   什么是水仙花数：
      三位数 100 -999    例如：123
   求出个位 %10  十位    百位/100
   判断

   //逢7过
   /* public static void main(String[] args) {
      int count = 0;
      for (int i = 1; i <= 100; i++) {

         if ((i % 10 == 7 || i / 10 == 7) || (i % 7 == 0)) {

         } else {

            if (count % 5 == 0) {

                  System.out.println();
            }
            count++; //5
            System.out.print(i +", ");
         }

      }
*/

   while 循环：

      基本格式：

      while(条件判断语句){
   循环体;
   }

   其他格式：

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

do..while 循环：

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


   do..while 第一次执行无论条件是否成立都会执行
   for 循环循环次数已经明确知道的情况下使用
   while 循环循环次数不明确的

   死循环：
         while (true ){
   循环体;
   }

   for(;;){}


   break; //直接跳出循环

   continue; //直接跳出当前次的循环继续下一次的循环

/*
   Scanner sc = new Scanner(System.in);
      System.out.println("第一个数据：");
      int num1 = sc.nextInt();
      System.out.println("第二个数据：");
      int num2 = sc.nextInt();

      //最大公约数； 5  25    5       1 - 15 25%i==0 && 15%i==0
      int max = num1 > num2 ? num1 : num2;
      int min = num1 < num2 ? num1 : num2;

      for (int i = min; i > 0; i--) {
         if (max % i == 0 && min % i == 0) {
            System.out.println(i);
            break;
         }
      }

*/

Random随机数：
1.导包
   import java.util.Random;
2.创建对象
   Random r = new  Random();
3.调用方法：
   int num = r.nextInt(10);//生成一个数在10以内包括0但是不包括10;
   注意：
         生成A -Z的随机数  A（65）  Z（90）；
      应该写成：  r.nextInt(90-65+1)+65；


/**

         //输入一个数据  列出该数据的所有的因子  6    1,2，3、6
      //完数
      Scanner sc = new Scanner(System.in);
      System.out.println("请输入一个数字：");
      int num = sc.nextInt();

//       num = num/0;

      //如何获取该数据的因子

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

         if (num % i == 0) {

            System.out.println("因子：" + i);
         }

      }

}*/

/** 求最大公约数和最小公倍数

public static void main(String[] args) {
      Scanner scanner = new Scanner(System.in);
      System.out.println("请输入第一个数据：");
      int num1 = scanner.nextInt();
      System.out.println("请输入第一个数据：");
      int num2 = scanner.nextInt();

      //求最大公约数：5 25
      int min = num1 > num2 ? num2 : num1;
      int max = num1 > num2 ? num1 : num2;

      for (int i = min; i > 0; i--) {
         if (min % i == 0 && max % i == 0) {
            System.out.println("最大公约数是:"+i);
            break;
         }
      }

      //最小公倍数
      for (int i = max; i <= max * min; i++) {
         if (i % max == 0 && i % min == 0) {
            System.out.println("最小公倍数是:" + i);
            break;
         }

      }

}
*/

*
***
  *****
*******
*********
*******
  *****
***
*

/**
public static void main(String[] args) {

      for (int i = 0; i < 5; i++) {

         for (int j = 0; j < 4 - i; j++) {
            System.out.print(" ");
         }

         for (int j = 0; j <= i; j++) {
            System.out.print("*");
         }

         for (int j = 0; j < i; j++) {
            System.out.print("*");
         }

         System.out.println();
      }
      for (int i = 0; i < 4; i++) {
         for (int j = 0; j <= i; j++) {

            System.out.print(" ");
         }

         for (int j = 0; j < 4 - i; j++) {
            System.out.print("*");
         }

         for (int j = 0; j < 3 - i; j++) {
            System.out.print("*");
         }

         System.out.println();
      }

}*/
IDEA的安装和使用：
区分IDEA的项目和模块
      只要里面有.idea文件夹是不是project
   里面有对应的src和iml 属于模块

数组：
   一个容器能够存储多个相同类型的数据
   定义的格式：
         int[] arr;  double[] arr;
   // int arr[];
   数据类型[] 变量;

   动态初始化（创建）只需要知道一个是数据类型长度
      格式：
   数据类型[] 变量 = new 数据类型[长度];

      boolean[] b = new boolean[2];


   只要是看到中括号[] 优先考虑是不是数组
   长度指的是我们创建的数组里面存储几个具体的元素
      new 代表创建一个新的对象（在内存里面申请一个新的空间保存数据）

   如何访问数组里面的元素：
               根据索引(下标)

内存：
         硬盘内存    缓存（寄存器 CPU）

   **  栈区 Stack：
         1.存储的都是局部变量
2.方法执行的时候会进栈执行

   **  堆区  Heap：
            new 出来的东西都在堆区里面

         *  方法区：
         加载字节码文件

   本地方法栈
   寄存器


   静态初始化：

         格式：

         数据类型[] 变量 = new 数据类型[]{元素1,元素2,...};

   int [] arr = new  int[]{2,3,5,8};

               静态的省略格式不能拆分成两部分
   //例如：int [] arr = new  int[]{2,3,5,8};==> int [] arr; arr = new  int[]{2,3,5,8};
   //错误的案例： int [] arr ={2,3,5,8};  ==> arr ={2,3,5,8};

   变量也可以作为静态的元素存储
   // 例如： int a =10;  int b = 11;  int[] arr = {a,b};


   两个异常：
            ArrayIndexOutOfBoundsException  //数组的索引越界异常
      int[] arr = new int[5]; //最大索引是4  arr[6]

   NullPointerException //空指针异常  有没有给数组进行赋值

         //随机生成10个0-9之间的随机数存入数组中
int[] arr = new int[10];

Random rd = new Random();

for (int i = 0; i < arr.length; i++) {
int num = rd.nextInt(10);
arr[i] = num;
}

for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}



   //求最大值

   int[] array = { 5, 15, 30, 20, 10000, 30, 35 };

      int max = array[0]; // 比武擂台
      for (int i = 1; i < array.length; i++) {
         // 如果当前元素，比max更大，则换人
         if (array[i] > max) {
            max = array[i];
         }
      }
      // 谁最后最厉害，就能在max当中留下谁的战斗力
      System.out.println("最大值：" + max);
}

//求最小值

int[] array = { 5, 15, 30, 20, 10000, -20, 30, 35 };

      int min = array[0]; // 比武擂台
      for (int i = 1; i < array.length; i++) {
         // 如果当前元素，比min更小，则换人
         if (array[i] < min) {
            min = array[i];
         }
      }
      System.out.println("最小值：" + min);
}
方法：

   功能独立的代码块

   定义方法

   方法的调用

   方法的定义
         格式：
         public static void 方法名(){
方法体;
}

   方法的调用：

      现在都写在 main方法里面
      方法名();


   带参数的方法的格式:

      public static void 方法名(数据类型变量1,数据类型变量2...){
方法体;
}

方法的调用：
               方法名(实参);

         实际参数：方法调用的时候（写的时候就是一个常量）
   形式参数：定义方法的时候  变量


带参数带返回值的方法的定义格式：
                                 void
   public static 返回值类型  方法名(数据类型变量名1,数据类型变量名2,...){


      return 具体的返回值（常量/表达式）
   }

   返回值类型主要功能就是确定该方法有返回值而且限定了返回值的数据类型

   //ctrl +alt + V  会帮我们自动生成变量存储返回值


方法的注意事项：
         1.方法不能嵌套使用
   2.返回值如果有返回值类型（不是void）都需要 return 表达式; return 方法一旦走到return 一般都是表示方法结束

   // 统计一百内所有的带7的或者是能被7整除的数有多少个
   /***
      1. 返回值类型  统计个数  int
2. 参数不需要
3. 方法名  getSevenPassCount()
   */

方法重载： @OverLoad

条件：
      在同一个类中
   1.方法名相同
   2.方法的参数不同（1.数据类型不同  2.参数的个数不同 3.参数的顺序不同）

   为什么会有方法重载降低我们的学习程度

   基本的数据类型作为方法的参数传递的是数据值（值传递）

   引用数据类型作为方法的参数传递的是  地址值（地址传递）

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

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