APUE 学习笔记(一)

2017年西安区域赛 Sum of xor sum(线段树)

  返回  

Java基础内容/基础语法/流程控制

2021/8/21 20:43:14 浏览:

基础内容

1.如何高效的学好java

多写代码,多写笔记,多写文章
多练交流,多练思维,多练技能
多分享,多提问,多思考
最重要(坚持)

2.计算机应用领域

1)科学计算
2)数据处理
3)自动控制
4)计算机辅助设计
5)人工智能

3.计算机硬件组成

cpu,主板,内存,电源,主机箱,硬盘,显卡,键盘鼠标,显示器…
io设备(input/oupput):输入输出设备

4.计算机软件

计算机软件分为系统软件与应用软件

系统软件:DOS,Windows,Linux,Unix,IOS,Android,Mac
#应用软件:WPS,QQ,微信,英雄联盟,绝地求生…

5.DOS命令

DOS命令:

命令用法
exit退出当前DOS命令窗口
DOS复制:窗口中任意位置点击鼠标右键
dir列出当前目录下的所有子文件/子目录
cd( change directory【改变目录】)
cd …回到上级目录
cd \直接回到根部路径
c:回车 d:回车 e:回车 f:回车切换盘符
Ipconfig查看IP地址
Xxx -version查看版本
Del *删除
md创造一个文件夹
rd删除文件夹(必须为空)
rd /s /q强制删除
rd /s带内容的目录(文件夹):询问是否删除这个目录
cls清楚屏幕

6.Java的特性与优点

1.简单性
2.面向对象
3.可移植性(跨平台性)
4.高性能
5.分布式
6.动态性
7.多线程
8.安全性
9.健壮性

7.Java的三大版本

JavaSE:标准版(桌面程序,控制台开发…)
JavaME(手机,小家电…)
JavaEE(Web端,服务器开发…)

8.java的基本含义:

JDK:(Java Development Kit)java开发工具包
JRE:(Java Runtime Envirment)java运行环境
JVM:(Java Virtual Machine)java虚拟机

下载地址:https://www.oracle.com/java/technologies/javase/javase-jdk8-downloads.html

安装jdk完成之后:进入dos,输入java -version:查看当前本地的jdk的版本信息
安装好jdk之后:需要在安装目录的bin目录去使用的编译命令和执行命令

javac.exe 编译命令
java.exe 运行命令

path环境(系统配置):

配置path环境变量的原因:### 三级标题
我们需要在任何目录下使用javac和java对Java源文件进行编译和运行

方式1:(存在弊端)
win10/win8---->此电脑---->右键属性---->高级系统设置---->环境变量---->系统变量 找到path将jdk安装目录的bin路径复制到path里面即可!

path: jdk\bin的路径

弊端:
1)当jdk版本升级了,开发者需要手动更改path:可能造成的path其他变量更改了,所以不好!
2)二阶段使用tomcat服务器(使用java编写的),启动的时候会寻找计算机中系统变量中的path是否存在
JAVA_HOME,如果找不到,服务器启动时候出现"闪屏";

使用方式2:(推荐):
win10/win8---->此电脑---->右键属性---->高级系统设置---->环境变量---->系统变量

新建变量名:
JAVA_HOME
变量值:
jdk路径

优点:

1)不需要手动更改path
2)tomcat服务器启动的时候,找到JAVA_HOME变量,就不会出现闪屏

path环境变量的执行流程:

写好了java文件,对java文件进行编译和运行;

1)首先需要在dos中找到java文件的目录,如果找不到

2)就会在path环境变量中找%JAVA_HOME%\bin

3)如果path中都没有这个文件,那么久会提示 找不到文件…

classpath:临时环境变量(了解):
classpath执行流程:先在系统变量中寻找是否存在classpath的路径
如果存在优先的是这里面的xxx.class文件

基础语法

1.注释

单行注释

//注释当前行

多行注释

/*
注释内容
注释内容
...
*/

文档注释(javadoc)
Javadoc命令是用来生成自己的API文件
参数信息 :
1.@author:作者名
2.@version:版本号
3.@since:指明需要最早的jdk版本
4.@param:参数名
5.@return:返回值情况
6.@throws:异常抛出情况

/**
*\javadoc注释
*\javadoc注释
*\javadoc注释
*\javadoc注释
...
*/

2.标识符与关键字

2.1标识符

什么是关键字?
被Java语言赋予特定含义的单词!

用于定义数据类型的关键字名称
classinterface,byte,short,int
longfloat,double,char,boolean
void
用于定义数据类型值的关键字
truefalse,null
用于定义流程控制的关键字
ifelse,switch,case,default
whiledo,for,break,continue
return

2.2关键字

什么是标识符

​ 在Java原程序当中凡是程序员有权利自己命名的单词都是标识符(黑色字体)

​ 可以标识的元素:类名、方法名(main)、变量名、接口名、常量名(srgs)…

标识符的组成:

​ 一个合法的标识符只能由“数字、字母、下划线_、$”组成,不能含有其他符号

开头不能是数字
​ 严格区分大小写
​ 关键字(蓝色的)不能做标识符
​ 理论上无长度限制,最好不要太长

如果是单个单词:
字母全部小写
举例:

main()
    int price=100;

如果是多个单词:
第一个单词字母全部小写,从第二个单词开始每个单词首字母大写,其余小写(小驼峰命名法)

举例:

cheacUserNmae()
            int applePrice=100;

给常量命名的规则:
如果是单个单词:字母全部大写(推荐多个单词)

举例:

HELLO=100;

如果是多个单词:每个单词字母大写,单词和单词使用下划线隔开
举例:

HELLO_WORLD=100;

3.数据类型

3.1基本数据类型

3.1.1数值类型

整数类型
1.byte占一个字节的位置,取值范围是:-127-128,默认值为0;
2.short占两个字节的位置,取值范围是:-32768-32767,默认值为0;
3.int占四个字节的位置,取值范围是:-2147483648-2147483647,默认值为0;
4.long占八个字节的位置,取值范围是:-9223372036854775808-9223372036854775807,默认值为0
浮点类型
1.float占四个字节的位置,默认值为0.0f;
2.double占八个字节的位置,默认值为0.0d
字符类型
char占两个字节的位置,取值范围是:0-65535,默认值为false(0)

3.1.2boolean类型

占一个位的位置,其值只有True和False两个

字节

字节:是计算机中处理数据的基本单位,习惯用B。
1 byte = 8 bit(1bit表示一个二进制位)

1 KB = 1024 byte

1 MB = 1024 KB

1 GB = 1024 MB

1 TB = 1024 GB

整数型当中的byte类型,占用1个字节,所以byte类型的数据占用8个比特位。

3.2引用数据类型

数组 ,类,接口

3.3数据类型拓展

进制
二进制:0b
八进制:0
十进制
十六进制:0x

3.4数据类型的转换

由低到高
byte,short,char–>int–>long–>float–>double

public   calss 练习{
  public static void main(String[] args){
   /*
        100L是long类型字面值
        x是long类型变量
        不存在类型转换,直接赋值
        */
        long x=100L;
        /*
        x是long类型,8个字节
        y是int类型,4个字节
        编译报错,大容量不能直接变一个小容量
        int y=x;
        大容量转换小容量,需要进行强制类型转换
        强制类型转换需要加“强制类型转换符”
        加上强制类型转换符之后编译通过了,但是运行阶段可能损失精度
        随意强制类型转换谨慎使用,因为损失精度之后损失很严重
        强制转换原理
        原始数据 00000000 000000000 00000000 00000000 0000000 0000000 00000000 01100000
        强制转换之后:00000000 0000000 00000000 01100100

        将左边的二进制砍掉!
        */

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

        /*
        原始数据:00000000 000000000 00000000 00000000 10000000 00000000 00000000 000000000
        强制转换之后的数据:10000000 00000000 00000000 00000000(补码形式)
        以上补码转换到原码就是最终结果
        */

        long k=2147483648L;
        int e=(int)k;
        System.out.println(e);//损失精度非常严重,结果是负数【-2147483648】

        /*
        依据目前内容,以下程序无法编译
        理由:50是int类型的字面值,b是byte类型的变量
        显然是大容量int转换成的小容量byte
        大容量转换成小容量是需要添加强制转换符的,一下程序没有添加强制转换符号,所以编译报错
        但是,实际编译时,以下代码通过了,盖子面值可以直接赋值给byte类型的变量
        */

        byte b=50;//可以
        byte c=127;//可以

        //编译报错,128这个int类型的字面值超出了byte类型的取值范围,不能直接赋值给byte类型的变量
        //byte b1=128;

        byte b1=(byte)128;//-125

        /*
        纠正错误,需要使用强制类型转换符,但是一定会损失精度
        原始数据:00000000 00000000 00000000 10000000
        强制转换之后10000000【这是储存在计算机内部的,这是一个补码,】
        System.out.println(b1);
        */
  }
}

注意:
1.不能对布尔值进行转换
2.不能把对象类型转换为不相干的类型
3.在把高容量转换成低容量时,强制转换
4.转换的时候可能存在内存溢出或者精度问题

4.变量

变量是什么?
变量就是可以变化的量
变量本质上来说是内存中的一块空间,这块空间数据类型、有名字、有字面值
变量是程序中最基本的存储单元,其要素包括变量名,变量类型和作用域

变量的声明/定义变量名的格式
数据类型 变量名(合法标识符)

注意事项
1.每个变量都有类型,类型可以是基本类型也可以是引用类型。
2.变量名必须是合法的标识符。
3.变量声明是一句完整的语句,因此每一个声明都要以分号结束

变量的赋值:
语法格式:变量名=字面值(“=”是赋值运算符 )

Int i=10;//声明和赋值可以放在一起完成

/*
变量赋值之后,可以重新赋值(变量值可变)

有了变量的概念之后,内存空间得到后可重复使用
*/

int i=10;

System.out.println(i);//10

int i=100;

System.out.println(i);//100

...

...


变量的作用域
作用域:变量的有效范围,在什么范围之内是可以被访问的,只要出了这个范围,变量就不会被访问了。出了{}就不认识了。

变量的分类:
根据变量声明的位置来分类:

局部变量:在方法体中声明的变量

成员变量:在方法体外,类体之内声明的变量

(不同作用域中,变量名可以重名;同一作用域中,变量名不能重名)

变量的命名规范
1)所有变量,方法,类名:见名知意
2)类成员变量:首字母小写和驼峰原则,mounthSalary
3)局部变量:首字母小写和驼峰原则
4)常量:大写字母和下划线,MAX_VAULE
5)类名:首字母大写和驼峰原则,Man,GoodMan
6)方法名:首字母小写和驼峰原则,run(),runRun()

5.常量

初始化之后不会再改变值
1)字面值常量
整数常量:所有的整数
小数常量:所有的小数
字符常量:单引号引起来,只有一个字符,必须有内容
字符串常量:双引号引起来的内容,可以写多个,也可以不写
布尔常量:只有两个值,true和false
空常量;只有一个值

**字符串常量:**使用双引号包裹起来的内容:称为"字符串常量"
举例:
“我爱高圆圆”
“HelloWorld”
**字符常量:**使用单引号包裹起来的内容
举例:
‘a’,‘A’,‘0’
‘我’
‘abc’ 非法数据(只能单引号括起来的单个内容)
整数常量:
100 包含"进制" 整数----默认十进制
64

小数常量:
3.14
12.56
布尔常量:true false

空常量:null
引用数据类型默认值null

2)自定义常量
(面向对象后面讲:关键字:final:状态修饰符)

6.运算符

运算符有优先级,一个表达式当中有过多个运算符,不确定的加(),优先级得到提升

​ ++出现在变量后,先做赋值运算,在对变量中保存的值进行自加1

int a=100;
int b=a++;
//a=a+1;
System.out.println(a);//101
System.out.println(b);//100

int e=100
System.out.println(e++);//100
System.out.println(e);//101

++出现在变量前,先进性自加1,在进行赋值

int n=200;
//n=n+1;
int m= ++n;
System.out.println(n);//201
System.out.println(m);//201



int n=200;
System.out.println(++n);//201
System.out.println(n);//201

关系运算符
​ 关系运算符的运算结果一定是布尔类型:true/false

逻辑运算符
​ & 逻辑与 (两边的算子都是真,结果才为真)

​ | 逻辑或 (两边算子只有一个是真,结果就是真)

​ ! 逻辑非 (取反)

​ ^ 逻辑异或 (两边算子不一样(真假/假真),结果就是真)

​ && 短路与 (与逻辑与运算结果相同,不过短路与存在短路现象)

​ 前半被判为false,整句便是false,后半便不再执行(比逻辑与更智能)

​ || 短路或 (与逻辑或运算结果相同,不过短路或存在短路现象)

​ 前半为真,整句为真,后半不再执行

​ 逻辑运算符要求两边的算子都是布尔类型,并且逻辑运算符最终的运算结果也是一个布尔类型

赋值类运算符
基本的赋值运算符:
​ =

扩展的赋值运算符:
​ += -= *= /= %=

字符串连接运算符
关于java中的“+”运算符

1.加法运算(数字+数字)

2.字符串的连接运算(字符串+字符串)

3.在一个表达式当中可以出现多个“+”,在没有添加小括号的前提下,遵循自左向右依次运算

int a=1;
int b=2;
System.out.println(a+“+”+b+“=”+(a+b));//1+2=3
System.out.println(""+a+b);//1020
System.out.println(a+b+"");//30

三元(三目/条件)运算符
语法规则:

布尔表达式?表达式1:表达式2

执行原理:

当布尔表达式结果为真时,选择表达式1作为整个表达式的执行结果

当布尔表达式结果为假时,选择表达式2作为整个表达式的执行结果

boolean sex=true;

Char c =sex ? ‘男’:‘女’;//男

位运算符

位运算符含义
<<乘2的n次幂
>>除2的n次幂
>>>被移位二进制最高位无论是0还是1,空缺位都用0补。
int A=00111100;
int B=00001100;
System.out.println(A&B);//按位比较,全1为1,有零为零:00001100
System.out.println(A|B);//按位比较,有1为1,全零为零:00111100
System.out.println(A^B);//按位比较,相同为0,不同为1:00110000
System.out.println("-----------------------------------------------------------")
System.out.println(~B);//比较上面的值,按位取反:11110011

包机制
为了更好的组织类,Java开发了包机制,用于区别类名的命名空间。
包语句的语法格式:
package pkg1[.pkg2[.pkg3…]];

一般运用公司类名的倒置用作包名

为了能够使用某一个包的成员,我们需要在Java程序中明确导入该包,使用“import”语句
可以完成此功能。
import package1[.package2…].(classname|*);

Import com.xue.base.*//*代表会导入包中的所有类

流程控制

1.用户交互Scanner

我们可以通过Scanner来获取用户的输入。
基本语法:
Scanner s=new Scanner(System.in);

通过Scanner类的next()与nextLine()的方法获取输入的字符串,在读取前我们一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据。
在这里插入图片描述
next():
1.一定要读取到有效的字符后才可以结束输入;
2.对输入有效的字符之前遇到的空白,next()方法会自动的将其去除掉;
3.只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符;
4.next()不能得到带有空格的字符串

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

在这里插入图片描述

eg:输入一些数,可以计算出这些数的平均值及和,每输入一个数字用回车确认,通过输入非数字 来结束程序并执行结果。
在这里插入图片描述

2.顺序结构

3.选择结构

3.1if语句

if语句的语法结构:四种编写方式

/*PS.对于java中的if语句来说,只要有一个分支执行,整个if语句全部结束。*/

//第一种:
if(布尔表达式){
/*
java语句;
java语句;
java语句;
java语句;
...
*/
}

//第二种:
if(布尔表达式){
/*java语句;
java语句;
...
*/
}else{
/*
java语句;
java语句;
...
*/
}

//第三种:
if(布尔表达式){
/*
java语句;
java语句;
...
*/
}else if(布尔表达式){
/*
java语句;
java语句;
...
*/
}else if(布尔表达式){
/*
java语句;
java语句;
...
*/
}.....

//第四种:
if(布尔表达式){
/*
ava语句;
java语句;
...
*/
}else if(布尔表达式){
/**
java语句;
java语句;
...
*/
}else if(布尔表达式){
/*
java语句;
java语句;
*/
...
}else{
/*
java语句;
java语句;
...
*/
}   

第二种编写方式和第四种编写方式都带有else分支,这两种方式可以保证100%会有分支执行。
所有的控制语句是可以相互嵌套使用的。只要河里嵌套就行。
嵌套使用时,代码格式保持完美。【该缩进时,必须缩进】
if语句的分支中只有一条java语句时,大括号可以不写。

3.2switch语句

switch语句的语法结构:

switch(int或String类型的字面值或变量){
    case int或string类型的字面值或变量:
    	java语句;
    	...
    break;
    case int或string类型的字面值或变量:
    	java语句;
    	...
    break;
    case int或string类型的字面值或变量:
    	java语句;
    	...
    break;
    Default:
    	java语句;
    	....
}

执行原理:

1 switch后面小括号当中的“数据”和case后面的“数据”进行一一匹配,匹配成功的分支执行。
2 按照自上而下的顺序依次匹配。
3 匹配成功的分支执行,分支当中最后有“break”语句的话,整个switch语句终止。
4 匹配成功的分支执行,分支当中没“break”语句的话,直接进入下一个分支执行(不进行匹配),这种现象被称为case穿透现象(提供break语句可以避免穿透现象)
5 所有分支都没有匹配成功的话,当有default语句时,会执行default语句中的
6 switch后面和case后面只能是int或string类型的数据,不能是其他类型
当然byte short char也可以直接写到switch和case后面,因为他们可以进行自动类型转换转换成int类型。
7 case可以合并:

int i=10;

switch(i){

	case1:case2:case3:

		System.out.println(“test code!”);

}

4.循环结构

4.1 while循环

while循环的语法结构:

while(布尔表达式){
	循环体;
}//表达式为true时,执行循环体

while循环的循环次数:0到N次,while循环的循环体可能一次都不执行

//输出0-10:
public class ArrayOutPut {
	public static void main(String[] args){
		int i=0;
		while (i<10){
			System.out.print(i+"\t");
			i++;
        }
	}
}

4.2do…while循环

\do…while循环的语法结构:

do{
循环体;
}while(布尔表达式);

do…whlie循环体代码片段执行次数是:1-N次(至少一次)

do…while循环的注意事项:do…while循环语句最终有一个分号

4.3 for循环

for语句的语法结构:

for(初始化表达式;布尔表达式;更新表达式){
	//是需要重复执行的代码片段【循环体:由java语句构成】
}
eg:
public class JavaApplication5 {
    public static void main(String[] args) {
    
   for(int i=1;i<=10;i+=2 ){
             System.out.println("i="+i);
    }
    
    for(int j=2;j<=10;j+=2 ){
             System.out.println("j="+j);
    }
    
    for(int k=10;k>0;k-- ){
             System.out.println("k="+k);
    }
    
    for(int z=100;z>0; ){
             System.out.println("z="+z);
             z-=10;
    }
    }
}

循环语句和条件判断语句嵌套使用

最好不要想太多,即使循环体当中是一个for循环,不要将这个for特殊化,

【for和if的嵌套】

eg2:

//100以内的所有质数
public class ForFor嵌套求质数 {
    public static void main(String[] args) {
        //给范围
        for(int i=2;i<=100;i++){
           //求素数
           boolean sushu = true;
           for(int j=2;j<i;j++){
               if(i%j==0){
                  sushu = false;
                  break;
               }      
           }
           //输出
           if(sushu){
                System.out.print(i+"\t");
           }
    }   
    }
}

eg3:

//10000以内的所有质数,每八个数字换一行

//方法①
public class ForFor嵌套求质数 {
    public static void main(String[] args) {
        int count=0;
        //给范围
        for(int i=2;i<=10000;i++){
           //求素数
           boolean sushu = true;
           for(int j=2;j<i;j++){
               if(i%j==0){
                  sushu = false;
                  break;
               }      
           }
           //输出
           if(sushu){
               count++;
               System.out.print(i+"\t");
                if(count%8==0){
                   System.out.println();
               }
           }
        }   
    }
}

//方法②
public class 求质数升级版 {
     public static void main(String[] args){
         int count=0;
         for(int i=1;i<10000;i++){
             boolean sushu = true;
             for(int j=2;j<i;j++){
                 if(i%j==0){
                  sushu = false;
                  break;
               }      
           }
           //输出
             if(sushu){
               count++;
               System.out.print(i+"\t");
                 if(count==8){
                   System.out.println();
                   count=0;
                }
            }
        }  
    }   
}

增强for循环
语法格式:
for(声明语句:表达式){
代码句子
}
eg:数组中输出 数组中的所有元素

public class forZengQiang {
	public static void main(String[] args){
		int[] numbers = {10,20,30,40,50};
		for(int x:numbers) {
			System.out.println(x);
		}
}
}

4.4跳转语句

4.4.1break
break是Java语句中的关键字,翻译为“中断/折断”
break+“;”可以成为以单独的完整java语句:break;
break语句使用在switch语句当中,用来终止switch的语句执行。
break语句同样可以使用在循环语句当中,用来终止循环的执行
break语句使用在for、while、do…while循环语句当中用来跳出循环,终止玄幻的执行。因为当程序循环到某个条件的时候,后续循环没必要执行,在执行也是耗费资源,所以可以终止循环,这样可以提高程序的执行效率。
在默认情况下,break终止的是离他最近的循环语句:

4.4.2continue
continue表示是:继续/下一个
continue的java语句:continue;

break和continue的区别:
break:跳出循环

continue:进入下一循环

见下文…

联系我们

如果您对我们的服务有兴趣,请及时和我们联系!

服务热线:18288888888
座机:18288888888
传真:
邮箱:888888@qq.com
地址:郑州市文化路红专路93号