jJava第一章和第二章

学习目标：

学会Java！！

---

学习内容：

第一章：概述第一个程序 第二章：基础语法

---

学习时间：

2021年3月14日

---

学习产出：

1、上课笔记一份 2、CSDN笔记一遍 3、练习一份

第一章：概述第一个程序

为什么学习Java

1、java语言主要用于应用程序开发

2、java语言用途广

● 服务器程序
银行,证券交易平台,电子商务后台…

● Android应用
安卓手机,各种移动设备,智能家电…

● 软件工具
开发工具eclipse, IneteliJIdea

● 嵌入式领域
智能卡,传感器上

● 大数据技术
Hadoop以及其他大数据处理技术都是用Java

3、工作岗位需求多。

Java语言发展史

1991年 在 sun公司

提出研发需求:

内存小且cpu不同

在James Gosling(詹姆斯•高斯林)带领下

1995年正式确立.

2004 1.5版本发布(重大语法升级变革) 命名java5

2009 sun被oracle公司收购

现在java每半年更新一次版本

Java语言的特点

1、开源（免费）

2、跨平台性

java源代码只需要编写一次 编译 为字节码文件

翻译(java虚拟机 类加载 运行时数据存储 执行引擎) JVM

在不同的平台(操作系统)上运行

java语言与平台无关

JVM与平台相关

3、面向对象

4、多线程机制

5、交互性特性

6、动态的内存管理机制

7、安全性

Java的体系结构

JavaSE（包含java基础核心的类:字符串,日期,集合,异常,IO,线程,GUI,网络编程）

JavaEE（javaEE中包含JavaSE, servlet(server applet),jsp ）

JavaME（基本被安卓开发取代）

Java语言的运行机制

创建.java文件(源代码)----->编译器----->.class文件(字节码)------>不同平台的JVM------>翻译------>指令----->平台运行

Java运行环境的安装与配置

下载安装jdk

JDK(Java Development Kit Java开发工具包)

jdk针对于开发人员的工具包

里面包含一些工具(编译器,打包,测试工具), JRE(Java Runtime Environment Java运行环境) ,JVM负责执行class文件

开发第一个java程序

public class Hello{
	
	 public static void main(String [] args){
		 
		 System.out.print("hello world");
		 
	 }
	
}

通过javac命令 将.java文件编译成.class文件

然后通过java命令运行类

由于使用这些命令,需要到bin目录中才可以.很不方便

解决办法:

在系统环境变量 Path中将D:\ProgramFiles\Java\jdk1.8.0_261\bin配置到path中
在任何目录中都可以使用java命令

第二章：基础语法

IDE使用

IDE(Integrated Development Environment )集成开发环境,是用于

提供程序开发环境的应用程序，一般包括代码编辑器、编译器、调试器

和图形用户界面等工具。

● 常用的java开发工具有

IntelliJ IDEA 免费下载 使用收费

Eclipse 完全免费

安装设置参考文档

注释

使用的特定的符号标记的内容,对代码功能的解释
// 单行注释

/*
多行注释
*/

/**
文档注释（用于为类,成员变量,方法的功能进行说明,在调用时可以提示）
*/

package day1;

/**
 * 注释的演示
 */
public class Demo1 {
    public static void main(String[] args) {
         //年龄
         int age;
         /*
           姓名
           注意不能为空
          */
         String name;
        Demo1.eat("jim");
        System.out.println();
    }
    /**
     吃饭的方法
     name:姓名
     */
    public static void eat(String name){
    }
}

关键字

java中被赋予特定含义的单词,主要用来修饰包,类,变量,方法。

保留字：
现有Java版本尚未使用，但以后版本可能会作为关 键字使用。自己命名标记符时要避免使用这些保留字（goto 、const）

标识符

对包,类,变量,方法等进行命名的字符序列 通俗讲自己可以命名的名称

命名需要遵守规则:

语法强制规范:

大小写字母,数字,下划线 $

数字不能开头,不能是关键字,不能有空格,区分大小写

公司规范

​ 包名:单词全部小写（xxxyyyzzz）

​ 类名:首字母大写 大驼峰（XxxYyyZzz）

​ 变量名,方法名:小驼峰（xxxYyyZzz）

​ 常量名:全部大写 单词之间用_连接（XXX_YYY_ZZZ）

​见名知意

变量

程序中基本的存储单元,运行时值可变。

声明变量:

[修饰符] 数据类型  变量名 [=值];

数据类型

基本数据类型

package day1;
/*
数值类型
 */
public class Demo3 {

    public static void main(String[] args) {

        //1字节
        byte a = 127;

        //2字节
        short b = 32767;

        //4字节
        int c = 2147483647;
        System.out.println(Integer.MAX_VALUE);

        //8字节
        long d = 2147483649L;

        //八进制整数  0开头
        int e = 011;
        System.out.println(e);

        //二进制 0b开头
        int f = 0b11;
        System.out.println(f);

        //16进制 0x
        int g  = 0xf;
        System.out.println(g);

        int x;
         x=10;
        System.out.println(x+1);//变量在使用前必须赋值
        
        //float 4字节
        float m = 10.5F;

        //double 8字节
        double n = 20.5;
    }
}

字符型

package day1;

/*
字符型
 */
public class Demo4 {

    public static void main(String[] args) {

         char c = 'a';//97-->二进制
         char d = '中'; //20013 0xffdda存储    utf-8就是在网页,文件中显示时对照表

        //在运算时,char会转为int(在编码表中的十进制编号)
        System.out.println(d+0);
        System.out.println(d<10);

         /*
           计算机是不能识别字符的?
           编码表
           a--97
           b--98
          */
    }
}

数据类型转换

java中可以从任意基本类型转型到另外的基本类型

例外 ： boolean 类型不可以转换为其他的数据类型

默认转换

整形，字符型，浮点型的数据在混合运算中相互转换，转换时遵循以下原则：

容量小的类型默认转换为容量大的数据类型；

数据类型按容量大小排序为： byte,shor t,char->int->long->float->double

byte,shor t,char之间不会互相转换，他们三者在计算时首先会转换为int类型 。

强制转换

容量大的数据类型转换为容量小的数据类型时，要加上强制转换符，但可能造成精 度降低或溢出；

使用时要格外注意。

有多种类型的数据混合运算时，系统首先自动的将所有数据转换成容量最大的那一 种数据类型，然后再进行计算。

package day1;

/*
   基本数据类型之间的转换
     除了boolean型,其他7种之间可以进行相互转换

 */
public class Demo5 {

    public static void main(String[] args) {
        /*
           默认转换
             byte,short,char-->in-->long-->float-->double
             容量小的数据类型  默认自动转为容量大的
         */
          byte b=127;
          int c= 2147483647;
          long d = c;
          float f = d;

          /*
          容量大的 转为 容量小的
           强制类型转换
             问题:
               数据溢出
               精度损失
           */

          int x = 258;
          byte y = (byte)x;
        System.out.println(y);

          float m = 10.5F;
          long n = (long)m;
        System.out.println(n);
    }
}

算术运算符

/*
  算术运算符
   + - * / % ++ --
   + 加法  字符串连接
   - * / % 只能进行算数运算
 */
public class OperateDemo1 {

    //java程序的入口/主方法/主线程
    public static void main(String[] args) {
             int a = 10;
             int b = 5;
             char c  = 'd';//100
             String d = "100";
             String e = "aa";
        System.out.println(a+b);
        System.out.println(a+c);//整数+char(int)
        System.out.println(a+b+d);// 数值+(连接)字符串==字符串
        System.out.println(d+e);//字符串+字符串=字符串
        System.out.println(a-b);
        System.out.println(a-c);
        //System.out.println(a-d);

        //++  每++一次 在原来的基础上+1 再赋值
        //单独使用时++在前/后没有区别,在混合运算时++在前先自增后运算,反之则先运算后自增
        // --
        int x = 5;
            //x++;//x=x+1  6
            //++x;//x=x+1  7
        //int y = x++;
        int y = ++x;
        System.out.println(x);//6
        System.out.println(y);//6
    }
}

特别注意加号+

加号有加法 和字符串连接两个作用

算术运算符

比较运算符的结果都是boolean型，也就是要么是true，要么是false。

注意:比较运算符“==”不能误写成“=” 。

/*
   比较运算符
   ==
   !=  数值,布尔,引用类型
   > < >= <= 适用于数值类(char)
   instanceof 类型检测
 */
public class OperateDemo2 {

    //java程序的入口/主方法/主线程
    public static void main(String[] args) {
        //==
        int a = 10;
        int b = 5;
        boolean c = true;
        boolean d = false;
        String e = "abc";
        String f = "efg";
        System.out.println(a==b);
        System.out.println(c==d);
        System.out.println(e==f);
        //!=
        System.out.println(a!=b);
        System.out.println(c!=d);
        System.out.println(e!=f);

       /* System.out.println(e>f);
        System.out.println(c>e);*/

        Object x = 10;
        //Object类型可以表示任何类型,但是实际表示的是哪种类型呢?
        System.out.println(x instanceof Integer);
    }
}

逻辑运算符

/*
    逻辑运算符
     &       |        !     ^  可以参与逻辑运算还可以参与位运算
     逻辑运算: true & false
     位运算: 二进制bit位运算  6 & 3

     &&(短路与)   ||(短路或)

 */
public class OperateDemo3 {

    //java程序的入口/主方法/主线程
    public static void main(String[] args) {
         int a = 10;
         int b = 5;
         int c = 6;
         int d = 20;

       /* //& 左右都为true 结果为true  遇到第一个false时,后面的表达式继续执行
        System.out.println(a>b&b<c);//true & true = true
        System.out.println(a>b&b>c);//true & false = false
        System.out.println(a<b&b>c);//false & false = false

        //&&左右都为true 结果为true   遇到第一个false时,就发生短路,后面的表达式就不在执行了
        System.out.println(a>b&&b<c);//true && true = true
        System.out.println(a>b&&b>c);//true && false = false
        System.out.println(a<b&&++b>c);//false && false = false
        System.out.println(b);*/

        //| 只要有一为true 结果为true
        System.out.println(a>b|b<c);//true | true = true
        System.out.println(a>b|b>c);//true | false = true
        System.out.println(a<b|b>c);//false | false = false

        //||只要有一为true 结果为true 只要遇到第一个true 后面的表达式就不行了
        System.out.println(a>b||b<c);//true || true = true
        System.out.println(a>b||++b>c);//true || false = true
        System.out.println(a<b||b>c);//false || false = false
        System.out.println(b);

       /* //!
        System.out.println(!(a>b));
        
        //^  异或运算  相同为false  不同为true
        System.out.println(a>b^b<c);//true ^ true = false
        System.out.println(a>b^b>c);//true ^ false = true
        System.out.println(a<b^b>c);//false ^ false = false*/
    }
}

赋值运算符

/*
   赋值运算符
   =  注意在赋值时,值的类型与声明的变量类型一致.
      牵扯到数据类型的转换(基本类型之间) 自动转换,强制转换
   扩展赋值运算
   +=
   -=
   *=
   /=
   %=
 */
public class OperateDemo4 {

    //java程序的入口/主方法/主线程
    public static void main(String[] args) {

         byte a = 12;//隐式的将int12 转为 byte
         int b = a;
         short c = (short)b;//int的b需要被强制转换成short型的才能进行赋值

         float d = 10.5f;
         int e = (int)(c+b+d);//混合运算时,数据类型默认会转为表达式中最大的类型

       /* int x = 5;
        long y = 10;
            x += y; // x=x+y
        System.out.println(x);*/

        short s = 3;
              //s=s+2; s = short+ int = int
              s+=2;//隐式转换 short + int = short


    }

条件运算符

package day2;

/*
     条件运算符(3元运算符)
      类型  结果 = (条件表达式)?表达式1:表达式2
       必须返回一个结果,结果的类型与定义结果类型一致

      if(条件){
        ssss
      }else{
        ssss
      }
 */
public class OperateDemo5 {

    //java程序的入口/主方法/主线程
    public static void main(String[] args) {

         int score = 70;

        String res = (score>=60)?"考试及格":"挂科";
        System.out.println(res);

    }
}

位运算

package day2;

import java.util.Arrays;
import java.util.LinkedList;

/*
    位运算符, 二进制的bit位的运算
    <<
    >>
    >>>
    &
    |
    ^
    ~
 */
public class OperateDemo6 {

    //java程序的入口/主方法/主线程
    public static void main(String[] args) {
       // <<  010  左移1位  100  乘法
       int a  = 2;
        System.out.println(a<<2);//左移两位

        //带符号
       //>> 0000 0011 右移 1位
       //>> 1000 0011 右移 1位
       int b = -6;
        //System.out.println(b>>1);

        //>>> 无符号右移 0111 1010 右移 1位  最高位只需要补0
        System.out.println(b>>>1);

        /*
          & 按位与
            0000 0110
          & 0000 0011
                 0010
         */
        int c = 6;
        int d = 3;
        System.out.println(c&d);


         /*
          | 按位或
            0000 0110
          | 0000 0011
                 0111
         */

        System.out.println(c|d);

        /*
          ^ 按位或
            0000 0110
          ^ 0000 0011
                 0101

           0000 0101
           0000 0110
                0011
         */
       /* int a = 6;
        int b = 3;

            a=a^b;
            b=a^b;
            a=a^b;
        System.out.println(a);
        System.out.println(b);

        System.out.println(a+b>b+a);*/
        //~  按位取反
         int e = 6;
        System.out.println(~e);
        /*System.out.println(Integer.toBinaryString(-6));*/
    }
}

表达式的运算顺序

控制台输入

package day2;

import java.util.Scanner;

public class ScannerDemo {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);//System.in 获得输入流对象 InputStream
            System.out.println("请输入用户名");
            String name =   scanner.next();// 阻塞式IO  输入时进入阻塞状态,等待,按回车键输入结束 继续执行
            System.out.println(name);

            System.out.println("请输入年龄");
            int age = scanner.nextInt();
            System.out.println(age);
    }


}

控制语句

if语句和switch语句

package day2;

public class IFDmeo {

    public static void main(String[] args) {
        int score = 50;
        if(score>=60){
            System.out.println("及格");
        }//一般用大括号表示一个整体括起来

        if(score>=60)
            System.out.println("这门分数及格");  //if语句只对最近的一行代码有作用
        System.out.println("aaaaaaa");

        /*
          if(条件){ 表达式 }
          if(条件){ 表达式1 }else{  表达式2 }
          if(条件1){ 表达式1 }else if(条件n){  表达式n }
          if(条件1){ 表达式1 }else if(条件n){  表达式n }else{  }
         */

    }
}

package day2;

public class SwitchDemo {

    /*
       语法:
       表达式值类型:byte short int char 枚举 String
       case后面的值是常量,不能重复
       某个语句块中没有执行break 会进入到下一个case
       所有的case都不匹配 执行default
       switch(表达式){
          case  常量值1 :   语句块1   [break];
               ....
          case  常量值n :   语句块n   [break];
          default: 语句块
       }

       条件运算符: 二选一  必须返回一个结果
       switch: 一般适用于 固定的选项的匹配   效率高
       if : 适用于 区间,结果为布尔  更加灵活
     */

    public static void main(String[] args) {
         int a  = 8;
         switch (a){
             case 1 : System.out.println("星期1"); break;
             case 2 : System.out.println("星期2"); break;
             case 3 : System.out.println("星期3"); break;
             case 4 : System.out.println("星期4"); break;
             default:
                 System.out.println("不合法的日期");
         }
    }
}

循环语句

循环语句功能

在某些条件满足的情况下，反复执行特定代码的功能

循环语句的四个组成部分
循环变量的初始化 循环条件部分 循环体部分 循环变量的更新

循环语句分类
while 循环 do/while 循环 for 循环

package day2;

import java.util.Scanner;

public class WhileDemo {

    public static void main(String[] args) {

              while(true){
                  System.out.println(1);
              }

          /* int a = 1;
            while(a<=10){
                System.out.println(a);
                a++;
            }*/

        Scanner s = new Scanner(System.in);
            char c;
            do{
                System.out.println("请输入一个字母");
                c = s.next().charAt(0);
            }while(c>96&&c<124);//do while循环
    }
}

package day2;

public class ForDemo {

    public static void main(String[] args) {
       /*
         for(初始化变量(执行一次)1;(进入循环体的条件2)i<10;i++4){
                        循环体3
            }
        */

        for(int i=0;i<10;i++){
            System.out.println(i);
        }
        int i=0;
        for(;i<10;){
            System.out.println(i);
            i++;
        }//for括号内某些元素为空时也能执行

        /*for(;;){
            System.out.println(1);
        }*/

        for (int i = 0; i < 10; i++) {
                if(i==5){
                    //break;//终止循环,只能终止一层
                    continue;//只是终止当次循环,之后进入到下一次循环
                }
             System.out.println(i);
        }

    }
}

break & continue

break终止循环,只能终止一层

continue只是终止当次循环,之后进入到下一次循环

循环嵌套

将一个循环放在另一个循环体内，就形成了嵌套循环。

其中， for ,while ,do…while均可以作为外层循环和内层循环。

package day3;

public class ForDemo {

    public static void main(String[] args) {
        /*
           循环嵌套:在循环中再嵌套循环
             ****
             ****
             ****
             ****
         */
        /*for (int i = 0; i <4; i++) {
            for(int j=0;j<4;j++){
                System.out.print("*");
            }
            System.out.println();
        }*/

       /* for(int i=1;i<=9;i++){
            for(int j=1;j<=i;j++){
                System.out.print(j+"*"+i+"="+i*j+"\t");
            }
            System.out.println();
        }*/

        /*for(int i=2;i<=100;i++){
            boolean res = true;
            for(int j=2;j<i;j++){
                if(i%j==0){
                    res=false;
                   break;
                }
            }
             if(res){
                 System.out.println(i+"是质数");
             }
        }*/

     /*   while(true){
            System.out.println("输入账号密码");
            while(true){
                System.out.println("操作项1,2,3,4退出");
            }
        }*/

        /*在内层循环中 使用break关键字 结束指定的外层循环
        * 使用return也可以结束多层循环
        * */
        out:for(int i=0;i<=10;i++){
            for (int j = 0; j <10 ; j++) {
                if(j==5){
                    break out;
                }
                System.out.println("j="+j);
            }
            System.out.println("i="+i);
        }
    }
}

如果需要从多层循环跳出，则需要使用标签，定义一个标签,如label，然 后在需要跳出的地方，用break label就行了.

在内层循环中 使用break关键字 结束指定的外层循环

使用return也可以结束多层循环

Java中的方法

•Java的方法类似于其它语言的函数，方法是解决一类问题的步骤的有序组合, 方法包含于类或对象中.

[修饰符] [返回值类型void] 方法名(形参类型 形参名…){
方法体
[return 值]

package day3;

public class MethodDemo1 {
    /*
     主方法,java程序入口
     */
    public static void main(String[] args) {
        //调用方法,创建方法所在类的对象
        MethodDemo1 methodDemo1 = new MethodDemo1();
       /* byte r=5,c=3;
        methodDemo1.printStar(r,c);//注意数据类型
        methodDemo1.method1();
        methodDemo1.printStar(10,5);*/

       int res =   methodDemo1.max(10, 10);
        System.out.println(res);
    }

    //注意定义的返回值类型 与 实际返回的值类型要匹配(遵守类型转换规则)
    public int max(int a, int b){
         return a>b?a:b;
    }

    //打印星型
    public void printStar(int row,int col){
        for (int i = 0; i <row; i++) {
            for(int j=0;j<col;j++){
                System.out.print("*");
            }
            System.out.println();
        }
    }

    public  void method1(){
        System.out.println("方法的测试");
        //return;//return 语句后面如果没有值,只是让方法终止
    }


}

return语句

return语句用于从当前执行的方法中退出, 返回到调用该方法的语句处继续执行。

有两种格式:

return 表达式; //将表达式的值返回

return; //不返回任何值，当方法说明中用void声明无返回值时, 可以使用这种 格式，此类return语句有时可省略。