JAVA基础01-基本数据类型,流程控制,Scanner类的使用,基本类型,数组结构

java 开发环境配置 及java的三个版本

三个版本 JAVAME \JAVASE \JAVAEE

JAVVAME :嵌入式开发(手机\小家电…)

JAVASE: 标准版(桌面程序,控制台开发…)

JAVAEE: E企业级开发(web端,服务器开发…)

JDK\JRE\JVM

JDK

JDK: Java Development Kit

java 开发者工具, 包括JRE 和 JVM

还包括: java \ javac \ javadoc \ jar

java :运行

javac: 编译工具

javadoc: 可以变异成文档

jar: 可以打包发布

JRE: Java Runtime Environment :java运行时环境

包含JVM

JVM: Java Virtual Machine

java虚拟机,跨平台的保证, 两种运行方式: 编译型, 解释型

JAVA开发环境搭建

卸载

1. 删除java 的安装目录
2. 删除JAVA_HOME
3. 删除path 下面的java目录
4. doc 窗口 java -version 查看是否卸载

安装JDK

1. 百度直接搜索JDK8 , 找到下载地址
2. 同意协议,登陆
3. 查看电脑版本信息 ,下载响应版本
4. 双击.exe 安装
5. 记住安装路径
6. 配置环境变量
   1. 我的电脑右键点击属性 ->高级系统设置
   2. 点开,找到环境变量点击去
   3. 在系统变量点击新建, 变量名字 JAVA_HOME ,变量值,找到jdk安装路径
   4. 配置path 变量-点击编辑 新建 %JAVA_HOME%\bin %:代表引用的意思
   5. 一路确定, 然后doc命令 java -version

notepad++下载

Hello World

1. 新建一个文件夹.
2. 新建个java文件, 新建一个txt 修改后缀为.java
3. notePad 打开 编写代码
   public class HelloWorld{
   public static void main(String[] args){
   System.out.print(“Hello World”);
   }
   }
4. javac 编译HelloWorld.java
5. java HelloWorld 运行

JAVA程序运行机制编译型和解释型

编译型 compile

编译器:编译成JVM 认识的语言

解释型

解释器:解释成计算机可运行的语言

java基础知识

01注释

java中注释有三种:

• 单行注释

  • //注释
    
• 多行注释

  • /*多行注释*/
    

• 文档注释

  • /**
    *@Description HelloWorld
    *
    *
    *
    *文档注释*/
    

02 标识符

关键字

03数据类型

• 强类型语言
  • 要求变量的使用要严格符合规定,所有变量必须先定义后使用
• 弱类型语言
• Java的数据类型分为两大类
  • 基本类型(primitive type)
  • 引用类型(reference type)

变量

什么是字节

04:数据类型拓展及面试题讲解

05类型准换

由于java是强类型语言,所以要进行有些运算的时候,需要用到类型转换.

//强制类型转换会导致内存溢出问题
int i = 128;
byte b = (byte)i; // - 128  byte 最大是127
 //1.不能对布尔值进行转换
 //2. 不能把兑现队形转换为不相干的类型;
 //3. 在把高荣朗转换到底容量的时候,强制转换
 //4. 转换得时候可能存在内存溢出或者精度问题!

06: 变量,常量,作用域

变量

• 变量是什么:就是可以变化的量.
• java是一种强类型的语言,每个变量都必须声明变量名,变量类型和作用域.
• java变量是程序最基本的存储单元,其要素包括变量名,变量类型和作用域.
  type varName = [=value][{,varName[=value]}];
  //数据类型 变量名 = 值 ;可以使用逗号来隔开声明多个同类型的变量
  注意事项
  • 每个变量都有类型, 类型可以是基本类型也可以是引用类型;
  • 变量名必须是合法的标识符.
  • 变量名是一条完整的语句,因此每一个声明都必须以分分好结束

作用域

• 类变量

• 实例变量

• 局部变量

  public class Test01 {
  //类变量
  static String a = “”;
  //实例变量 ,从属于对象:如果不进行初始化, 这个类型的会有自己的默认值
  //布尔值: 默认是false;
  //除了 基本类型,其余数据类型都是null
  String s1 ;
  public static void main(String[] args) {
  //局部变量, 必须先声明在使用, 并且得初始化值;
  int i =10 ;
  }
  }

常量

• 常量(Constant):初始化(initialize)后不能改变值,不会变动值;
• 也可以理解为特殊的变量,它的值一旦设定,在程序运行期间不能更改;
  public class Test02 {
  //修饰符, 不存在先后顺序 (静态常量)
  static final double D =12.2;
  public static void main(String[] args) {
  System.out.println(D);
  }
  }
• 常量名一般用大写字符.

变量命名规范

• 所有变量,方法,类名:见名知意
• 类成员变量:首字母小写和驼峰原则:mothSala除了第一个单词以外后面的单词首字母大写
• 局部变量: 首字母小写 + 驼峰原则
• 常量: 大写字母 , 如果单词比较多中间+下划线: MAX_SEX
• 类名: 首字母大写和驼峰原则: 例:Test
• 方法名: 首字母小写和驼峰原则: run(); testRun();

07:基本运算符

算数运算符 关系运算符 逻辑运算符 位运算符 扩展赋值运算符 条件运算符 赋值运算符
+:加 >:大于 &&:与 &:与 +=:加等于 ? =
-:减 <:小于 ||:或者 |: 或 -=:减等于
*:乘 >=:大于等于 !:非 ^:异或 *=:乘等于
/:除 <=:小于等于 ~:取反 /=:除等于
%:取余 ==:等于 <<:左移 *2
++:自加 !=:不等于 >>:右移 /2
–:自减 instanceof:是否属于某一个类型 >>>

关于位运算符的介绍

 /*
    * A   = 0011  1100
    * B   = 0000  1101
    * -----------------------
    * A&B = 0000  1100  两1则1
    * A|B = 0011  1101  有1则1
    * A^B = 0011  0001  两个位置相同则为0 ,不同则为1
    * ~B  = 1111  0010  为0 则 1  为1 则零
    * --------------------------------------------
    * 面试题
    * 2*8  = 16怎么样做才能最快
    * 2*8 = 16 = 2*2*2*2
    * << 左移  *2
    * >> 右移  /2
    *
    * 0000 0000   ->0
    * 0000 0001   ->1
    * 0000 0010   ->2
    * 0000 0011   ->3
    * 0000 0100   ->4
    * 0000 1000   ->8
    * 0001 0000   ->16
    * */

08:自增自减运算符,初始math 类

Math类 :提供很多科学运算方法

09:逻辑运算符,位运算符

public static void main(String[] args) {
        // 与(and)   或(or)   非(取反)
        boolean a = true;
        boolean b = false;
        System.out.println("a && b"  + (a&&b));// 有假则假   false
        System.out.println("a || b"  + (a||b));//有真则真    true
        System.out.println("!a && b"  + !(a&&b));//若果为真就是假  true
    }

10:三元运算符|算木运算符

public static void main(String[] args) {
        int a = 10;
        int b = 20;
        a += b;  //a =a+b
        System.out.println(a);//30

        int c = 20;
        int d = 10;
        c -= d; //c = c-d
        System.out.println(c);//10

        int e = 10;
        int f = 20;
        //字符串拼接  字符串在前面,拼接 , 字符串在后面先进行运算;
        System.out.println("" + e+f);//1020
        System.out.println(e+f+"" );//30

        //三元运算符
        // x?y y:z  如果结果为真则输出y  ,否则则输出z
        int score  = 60;
        String type = score < 60 ?  "不及格":"及格";
        System.out.println(type);//及格
    }

运算符的优先级 ()优先

11:java中的包机制

• 为了更好的组织类,java提供了包机制,用于区别类名的命名空间.
• 包语法格式为

• package  pkg1[.pkg2.pkg3.....];
  //卸载代码第一行
  

• 一般使用公司域名到写作为包名: www.xunxun.com -> com.xunxun.项目名称(project)
• 为了能够使用某一个包的成员,我们需要在java程序中明确导入该包,使用import 语句即可

• import  com.xunxun.project
  //写在包名下面
  import com.xunxun.* 导入到xunxun下面所有的包类
  

12:javaDOC 生成文档

• javadoc 命令是用来生成自己的API文档的
• 参数信息

  • @author 作者名

  • @version 版本号

  • @sine 知名需要 最早使用的jdk版本

  • @param 参数名

  • @return 返回值情况

  • @throws 异常抛出情况

    javadoc -encoding UTF-8 setencoding UTF-8 类名

13:java流程控制01:用户交互Scanner 类

• java提供了很多工具类, 其中java.util.Scanner 是java5 的新特性可以使用Scnner来获取用户的输入
• 基本语法

• Scanner s = new Scanner(System.in);
  

• 通过Scnner类的next()与nextLine()方法来获取输入的字符串, 在读取前一般使用hasNext() 与hasNextLine()来判断是否还有输入的数据.

Scanner对象

• next()

  1. 一定要读取到有效的字符后才可以结束输入.
  2. 对输入有效字符之前遇到的空白, next()方法会自动将其去掉.
  3. 只输入有效字符后将其后面输入的空白作为分隔符或者结束符.
  4. next()不能得到带有空格的字符串

• nextLine():

  1. 以Enter 为结束符,也就是说nextLine()方法返回输入回车之前的所有字符
  2. 可以获取空白

  public static void main(String[] args) {
  Scanner scanner = new Scanner(System.in);
  System.out.println(“请录入字符串!”);
  if(scanner.hasNext()){
  String s = scanner.next(); // hello o o o
  System.out.println(“录入的字符串为:”+s); //录入的字符串为:hell
  }
  //关闭资源节省空间
  scanner.close();
  }
  public static void main(String[] args) {
  Scanner scanner = new Scanner(System.in);
  System.out.println(“请录入字符串!”);
  if (scanner.hasNext()) {
  String s1 = scanner.nextLine(); //rwerewr rwer
  System.out.println(“录入的字符串为:”+s1); //rwerewr rwer
  }
  //关闭资源节省空间
  scanner.close();
  }
  public static void main(String[] args) {
  Scanner scnner = new Scanner(System.in);
  System.out.println(“请录入字符串!”);
  String s = scnner.nextLine(); //gfg gfd
  System.out.println(“录入的字符串是:”+s); //gfg gfd
  scnner.close();
  }

14:Scanner 类的进阶使用

public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        //判断是否为整数
        System.out.println("请输入一个整数");
        if (scanner.hasNextInt()) {
            int i = scanner.nextInt();
            System.out.println("你录入的整数位:" + i);
        } else {
            System.out.println("你录入的不是整数");
        }
        System.out.println("请输入一个小数");
        //判断是否为小数
        if (scanner.hasNextFloat()) {
            float v = scanner.nextFloat();
            System.out.println("你输入的小数为:" + v);
        } else {
            System.out.println("你输入的不是一个小数");
        }
        //关闭资源
        scanner.close();
    }

public static void main(String[] args) {
        //我们可以输入多个数字,并求和与平均值,每输入一个数字按回车确认,通过输入非数字来结束输入King输出执行结果
        Scanner scanner = new Scanner(System.in);
        // 定义基准数;
        int sum = 0;
        // 定义计步器;
        int  num = 0;
        System.out.println("请录入整数以便求和");
        while(scanner.hasNextInt()){
            System.out.println("请录入第"+(num+1)+"整数");
            int i = scanner.nextInt();
            System.out.println("你输入的整数是"+i);
            num++;
            sum+=i;
            System.out.println("和是"+sum);
        }
        //关闭资源节省空间
        scanner.close();
    }

15:流程控制,顺序结构

• JAVA的基本结构就是顺序结构,除非特别指明,否则就按照顺序一句一句执行.

• 顺序结构是最简单的算法结构;

• 语句与语句之间,框与框之间是按从上到下的顺序进行的,他是有若干个一次执行的处理步骤组成的, 他是任何一个算法都离不开的一种基本算法结构.
  public static void main(String[] args) {
  System.out.println(“00001”);
  System.out.println(“00002”);
  System.out.println(“00003”);
  System.out.println(“00004”);
  System.out.println(“00005”);
  }

16java流程控制 : if选择结构

if选择结构

• if 但选择结构

  • 很多时候回判断一个东西是否可行
  • 语法:
    if(布尔表达式){
    //如果表达式为true 将执行括号内的语句
    }

• if 双选择结构

  • 相对于但选择,有时候我们还有更多的选择, 比如一个三叉路口,要么往左,要么往右
  • 语法

  • if(布尔类型){
    	//如果为true 则执行
    }else{
        //否则的话就位false此处语法执行
    }
    

• if 多选择结构

  • 有时候我们的选择情况不只有两种会有很多种这时候就会用到多选择结构
  • 语法
    if(布尔表达式1){
    //如果表达式1为true则执行
    }else(布尔表达式2){
    //如果表达式2为true则执行
    }else(布尔表达式3){
    //如果表达式3为true则执行
    }else(布尔表达式4){
    //如果表达式4为true则执行
    }else{
    //以上都不成立则执行
    }

• 嵌套的if结构

  • 语法也性对简单,比较容易理解
    if(表达式1){

        if(表达式2){
            
        }else{
            
        }
    }else{
        
    }
    

    每个if语句最好跟一个else 提高程序的可读性

17:jiava流程控制switch 多选择结构

• 多选择结构还有一个实现方式就是switch case 语句.
• switch case 语句判断一个变量与一系列值中某个值是否相等,每一个值成为一个分支
• switch 语句的变量类型可以是:
  • byte ,short, int , char
  • 从java1.7开始支持string类型
  • 同时case标签必须为字符串常量,或字面量

如果没有break 就会造成case穿透, 如果匹配到一个值相同,那么下面的语句也将输出,

default: 如果之前的都没有匹配到,那么会出处default 部分

18,循环结构

• while 循环

  • while 是最基本的循环,他的结构为:
    while(布尔表达式(条件)){
    //循环内容
    }
  • 只要布尔表达式为true, 循环就会一直执行下去
  • 大多数情况下不会都是会让循环停下来的, 我们需要一个让表达式失效的方法来结束循环.
  • 少部分的情况需要循环一直执行, 比如服务器的请求响应监听的
  • 循环条件一直为true 就会造成无限循环(死循环),正常的业务编码中尽量避免死循环,会直接影响程序的性能,造成程序卡死,崩溃

• do . . while 循环

  • 对于while 而言 如果不满足条件就不会进入循环,但是有时候即使不满足条件我们也要执行一次
  • do … while 循环和while 循环类似, 不同的是, do … while 循环至少会执行一次.

  • do {
    	//输出语句
    }while(布尔表达式);
    

  • while 和do …while 的区别
    • while先判断后执行, do while 是先执行后判断
    • Do . … while 总是保证循环体会被至少执行一次, 这是他们的主要差别

• for 循环

  • for 循环语句是支持迭代的一种通用结构, 是最有效, 最灵活的循环结构.
  • for 循环执行的次数是在执行前就已经确定的,
  • 语法
    for(初始化值;布尔表达式;更新){
    //代码语句
    };
    最先执行初始化步骤,可以声明一种类型,但可以初始化一个或多个循环控制变量,也可以是空语句
    然后,检测布尔表达式的值,如果结果为true 循环体执行,如果为false , 循环终止, 开始执行循环体后面的语句,
    执行一次循环后,更新循环控制变量(迭代因子控制循环变量的增减)
    再次检测布尔表达式,循环上面的过程
    for(; {
    //死循环
    }

• 在java5 中引入了一种主要用于数组的增强for循环

  • 主要用于遍历数组与集合的
  • 语法格式
    for(声明语句:表达式){
    //代码句子
    }
  • 声明语句:声明新的局部变量,该变量的类型

19 break continue

• break 在任何循环语句的主体部分,均可以用break 控制循环的流程, break用于强行退出循环,不执行循环中剩余的语句(break 语句也在switch 语句中使用)
• continue 语句用在循环句体中, 用于终止末次循环过程, 即跳过循环体中尚未执行的语句,接着进行下一次是否循环的判定;
• 关于goto 关键字
  • goto 关键字很早就在程序设计语言中出现,尽管goto 仍是java的一个保留字,但并未在语言中得到正式使用;java没有goto ,然而,在break 和continue这两个关键字身上,我们仍然能看出一些goto的影子–带标签的break 和continue
  • 标签, 是指后面跟一个冒号标识符.例如: label:
  • 对于java来说唯一用到标签的地方是在循环语句之前,而在循环之前设置标签的唯一理由是:我们希望在其中嵌套另一个循环,由于break 和continue 关键字通常只中断当前程序,若随着同标签使用,他们就会中断到存在标签的地方.

20 java中的方法

1. 什么是方法

   • java中方法是语句的集合,他们在一起执行一个功能
   • 方法包含于类或者对象中
   • 方法在程序中被创建,在其他地方被引用
   • 设计方法的原则:方法的本意是功能块, 就是实现某个功能的语句块的集合,我们设计方法的时候,最好保持方法的原子性,就是一个方法只完成一个功能,这样有利于后期的扩展
     格式:

   • //修饰符 返回类型  方法名  (参数列表)
     public static int add(int a, int b){
         //返回值
         return a+b;
     }
     

2. 方法的定义及调用

   • java中的方法类似于其他语言中的函数, 是一段用来完成特定功能的代码片段,一般情况下,定义一个方法包含以下语法;
   • 方法包含一个方法头和一个方法体:
     • 修饰符:修饰符,这个是可选的,告诉编译期如何调用该方法, 定义了该方法的访问类型.
     • 返回值类型:方法可能会返回值, return Value Type 是方法返回值的数据类型,有些方法执行所需的操作,但没有返回值,在这种情况下, return Value Type 是关键字void
     • 方法名: 是方法的实际名称,方法名和参数表共同构成方法签名;
     • 参数类型: 参数像是一个占位符,当方法被调用时, 传递给参数, 这个值被成为实参或变量,参数列表是指方法的参数类型,顺序和参数的个数, 参数是可选的, 方法可以不包含任何参数.
       • 形式参数:在方法被调用时用于接收外接输入的数据
       • 实参:调用方法时实际传给方法的数据/
     • 方法体:方法提包含具体的语句,定义该方法的功能
   • 方法的调用:
     • 调用方法:对象名.方法名(实参列表)
     • java 支持两种调用方法的方式,根据方法是否返回值来选择.
     • 放方法返回一个值的时候,方法调用通常被当做一个值,例如:
       int larger =max (20,50);
     • 如果方法返回值是void , 方法调用一定是一条语句.
     • 什么是值传递? 什么是引用传递;

3. 方法的重载

   • 重载就是在同一个类中,有相同的函数名称,但是形参不同的函数,
   • 方法重载的规则:
     • 方法名必须相同.
     • 参数列表必须相同(个数不同,或类型不同,参数排列顺序不同等)
     • 方法的返回类型可以相同也可以不相同.
     • 仅仅返回值类型不同不足以成为方法的重载;
   • 实现理论:
     • 方法名称相同是,编译期会根据调用方法的参数个数, 参数类型等去逐个匹配, 以选择对应的方法, 如果匹配失败, 则编译期报错;

4. 命令行传参

5. 可变参数

   • java1.5开始, java支持传递同类型的可变参数给一个方法.
   • 在方法声明中,在指定参数类型后加一个省略号(…).
   • 一个方法中只能指定一个可变参数, 他必须是方法的最后一个参数, 任何普通的参数必须在它之前声明

6. 递归

   • A方法调用B方法,很容易理解
   • 递归就是:A方法调用A方法, 自己调用自己
   • 利用递归可以用简单的程序来解决一些复杂的问题, 他通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解, 递归策略只需要少量的程序就可以描述出解题过程所需要的多次重复计算,大大地减少了程序的代码量, 递归的能力在于用有限的语句来定义对象的无限集合
   • 递归结构包括两部分
     • 递归头:什么时候不调用自身方法, 若果没有头,将陷入死循环.
     • 递归体: 什么时候需要调用自身方法;

21 数组

1. 数组的概述

   1. 数组是相同数据类型的有序集合.
   2. 数组描述的是相同类型的若干个数据, 按照一定的先后次序排列组合而成,
   3. 其中每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问他们.

2. 数组声明创建

   1. 首先必须声明数组变量,才能在程序中使用数组,下面是基本语法
      dataType[] arrayPefVar; //首选方法
      dataType array[]; //效果一样,但是不推荐
   2. java语言中使用new操作符来创建数组, 语法如下:
      dataType[] array = new dataType[长度]
   3. 数组的元素是通过索引访问的, 数组索引从0开始.
   4. 获取数组的长度, arr.length
      内存分析:

   三种初始化

   数组的四个基本特点:

   • 其长度都是确定的, 数组一旦被创建,他的大小是不可改变的.
   • 其元素 类型是相同的,不能是混合类型,
   • 数组中的元素可以是任何数据类型, 包括基本类型和引用类型.
   • 数组变量属于引用类型,数组也可以看做是对象,数组中的每个元素相当于对象中的成员变量;, 数组本身就是对象, java中的对象是在堆中的, 因此数组无论保存原始数据类型还是其他对象类型, 数组对象本身都是在堆中的;

3. 数组使用

   • forEach 增强for循环遍历
   • 数组当做入参
   • 数组当做返回值
   • 数组的操作…反转数组

4. 多维数组

   • 数组里面套数组

5. Arragys 类

   • 数组的工具类, java.util.Arrays
   • 由于数组对象本身并没有什么方法可以供我们调用,但是API中提供了一个工具类Arrays供我们调用,从而可以对数组对象进行一些基本的操作.
   • 查看JDK帮助文档
   • Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而不用使用对象来调用(不用 不是 不能)
   • 具有以下常用功能
     • 给数组赋值:通过fill方法.
     • 非数组排序,通过sort 方法, 按升序
     • 比较数组:通过equals 方法比较数组中的元素是否相等.
     • 查找数组元素:通过binarySearch 方法能对排序好的数组进行二分查找法操作

6. 冒泡排序

   • 冒泡排序是最为出名的排序算法之一,总共有八大排序算法;
   • 两两比较
   • 冒泡的代码还是相当简单的, 两层循环,外层冒泡轮数, 里层依次比较;
   • 当我们看到嵌套循环,应该立马就可以得出这个算法的时间复杂度为O(n2)

   •     public static void main(String[] args) throws InterruptedException {
              int[] array = {2, 4, 7, 3, 1, 7457, 32, 11, 754, 321, 523};
              int[] sort = sort(array); ///[1, 2, 3, 4, 7, 7457, 32, 11, 754, 321, 523]
              System.out.println(Arrays.toString(sort));
          }
          public static int[] sort(int[] array) throws InterruptedException {
              int temp = 0;
              for (int i = 0; i < array.length-1; i++) {
                  for (int j = 0; j < array.length-i; j++) {
                      if (array[j] > array[i]) {
                          temp = array[i];
                          array[i] = array[j];
                          array[j] = temp;
                      }
                  }
              }
              return array;
          }
     

7. 稀疏数组

   • 当一个数组中大部分元素为0,或者为同一个值的数组是,可以使用稀疏数组来保存该数组

   • 稀疏数组的处理方式是:

     • 记录数组一共有几行几列,有多少个不同值
     • 把具有不同值的元素和行列及值记录在一个小规模的数组中,从而缩小程序的规模

   • 如下图:左面是原始数组,右面是稀疏数组;

      public static void main(String[] args) {
             /**
              * 首先创建一个二维数组.类似于五子棋棋盘  我们用 0 代表空格 用 1 代表黑子, 用 2 代表白子  长宽  为11行 11列
              */
             int[][] array = new int[11][11];
             array[1][2] = 1;
             array[2][3] = 2;
             for (int[] ints : array) {
                 for (int anInt : ints) {
                     System.out.print(anInt+"\t");
                 }
                 System.out.println();
             }
             System.out.println("=================================");
             //将原来的数组压缩为稀疏数组
             //获取原来数组的有效值的个数
             int count = 0 ;
             for (int i = 0; i