黑马程序员--Java基础

——- android培训、java培训、期待与您交流！ ———-

Java

概述

Java是Sun(Stanford University Network)公司开发出来的一套编程语言，主设计者是詹姆斯·高斯林James Gosling，最大的特点就是跨平台运行。

分类

J2SE(Java 2 Platform Standard Edition)标准版

J2ME(Java 2 Platform Micro Edition)小型版

J2EE(Java 2 Platform Enterprise Edition)企业版

Java的开发环境主要使用JDK(Java Development ToolKit-Java开发程序包)，JDK是Java的核心，包含JRE(Java Runtime Envirnment-Java运行环境)，而JVM(Java Virtual Mechinal-Java虚拟机)又是JRE中的一部分，实现可移植性靠的是JVM。

三者间的关系

JDK：JRE+工具

JRE：JVM+类库

JDK的下载和安装

下载网址：www.oracle.com

安装方式：傻瓜式安装，下一步即可。

配置环境变量

作用

通过配置path环境变量，将javac指令所在目录也就是JDK安装目录下的bin目录配置到path变量下，即可使javac指令在任意目录下运行

步骤

1.进入“我的电脑”中“属性”里面的“高级系统设置”选择“环境变量”，在系统变量中新建变量名称为JAVA_HOME，变量值为jdk的安装目录。

2.配置path，一定要保留原先的path变量，在原先的基础上用”;”分隔开来，在最前面添加%JAVA_HOME%\bin，代表bin目录的路径。

3.保存好以后运行命令提示符，输入命令“javac”出现帮助说明就证明配置正确。

classpath默认当前运行路径，在系统变量中配置classpath，配置的路径为*.class放置的文件夹的路径，配置完成以后，无论java命令在任何位置执行，都会从classpath路径中查找文件。

临时设置classpath路径方法：set classpath=“路径”，只作用于当前运行的这个命令提示符窗口，窗口关掉以后失效。

Java的基础知识

Java语言基础组成

1.关键字

被java赋予了特殊含义的单词

2.标识符

在程序中自定义的一些名称

由26个大小写，数字 _ $组成

数字不能开头 关键字不能开头 严格区分大小写

规范：

包名：所有字母都小写 xxxyyyzzz

类名接口名：所有首字母大写 XxxYyyZzz

常量名：所有字母大写，多个单词的话用下划线连接 XXX_YYY_ZZZ

变量名和函数名： 第一个单词全小写，后面的所有单词首字母大写 xxxYyyZzz

3.注释

顾名思义，就是对Java语句做说明的语句

// 单行注释

/* */ 多行注释

/* / 文档注释

4.常量

表示程序运行时，数值不能改变的量

字面值常量：整数、小数、字符、字符串、布尔、null

自定义常量：类、接口、数组

5.变量

变量是内存中的一个存储空间，在程序运行过程中，其值在指定范围内可以改变的量。

变量的定义格式：

数据类型 变量名 = 初始化值;

例如：int i = 123;

6.进制

表现形式

二进制

由0和1组成，8个单位是1个字节 1个字节最大值是255，计算机采用此进制

八进制

0-7，满8进1，用0开头

十进制

0-9，满10进1

十六进制

0-9，A-F，满16进1，用0x开头

负数的二进制表现形式

-6：6的二进制取反+1 取反：将二进制的1变成0.0变成1

进制间的转换

十转二：对十进制数进行除2运算。没有余数为0 有余数为1。计算结果从右往左写。

例如，6的二进制表现形式为110。6除以2等于3，无余数得0。3除以2等于1，余数为1 得1。从右往左写就是110

二转十：二进制乘以2的过程。 从右往左运算

例如，110 0*2的0次方+1*2的1次方+1*2的2次方=0+2+4=6

其他进制转16进制：先转化为2进制，再转化为16进制

其他进制转8进制。三位代表一位进行转换

基本数据类型

byte：字节 8个二进制位 -128~127（-2的7次方~2的7次方减1）

short：短整型 16个二进制位 -21768~32767（-2的15次方~2的15次方减1）

int：整型 32个二进制位

long：长整型 64个二进制位

float：单精度 32个二进制位

double：双精度 64个二进制位

char：字符变量 16个二进制位

整数默认int

浮点默认double

长整数要加L或者l，单精度的浮点数要加F或者f。

数据间的转换

自动类型转换

byte b = 3

b= b + 2 不能运行

b占1个字节，2默认int类型占4个字节，不同的数据类型之间不能直接做运算，需要提升b的数值类型（小的向大的提升），运算结果也是4个字节，不能直接赋给b。3本身是整数，但在b的范围内，是个常量，所以可以赋给b。

强制类型转换

b = （byte）（b + 2）；

byte强制转换的是小括号里的内容，不加小括号的话，byte只会转换b，不会转换2，所以还是会报错。

运算符

算术运算符

+， - ， *， /

加减乘除就不用说了，大家都懂的~

说点特别的

%（取模即取余数 左边小于右边结果是左边。左边等于右边结果是0。右边是1结果是0。如果出现负数，结果只看被模数即左边）

++：a++ 表示给a进行+1运算，并将运算后的值重新赋给a，不等于a=a+1，因为a+1只进行+1运算，并没有把运算后的值重新赋给a。 b=a++：先将a的值赋给b，再进行自身+1运算。b=++a，先自身+1运算，再将运算后的值赋给b。

+：如果两个字符串之间用加号连接，那现在的加号就是字符串连接符。“He”+“llo”=“Hello” 字符串数据和任何数据使用+相连接，最终都会变成字符串。

\n：换行 \b：退格 \r：按下回车键（Windows系统中，回车符是由两个字符来表示\r \n） \t：制表符，相当于Tab键

给字符加双引号：(“\”Heloo\”“)

赋值运算符

=、+=、-=、*=、/=、%=

x+=4：把左右两边的和赋给左边 相当于x = x + 4 区别x = x + 4编译失败，因为数据类型不同，不能赋值，x=+4编译成功，因为+=运算符在给x赋值时，会自动完成强行转换动作

比较运算符

==：相等于

！=：不等于

运算完的结果不是true就是false

逻辑运算符

&：and与

|：or或

^：XOR异或

!：not非

class OperatorDemo {
public static void main(String[] args) {
int a = 3;
int b = 4;
int c = 5;

//&逻辑与
System.out.println((a > b) & (a > c)); //false & false = false
System.out.println((a > b) & (a < c)); //false & true = false
System.out.println((a < b) & (a > c)); //true & false = false
System.out.println((a < b) & (a < c)); //true & true = true
System.out.println("---------------");

//|逻辑或
System.out.println((a > b) | (a > c)); //false | false = false
System.out.println((a > b) | (a < c)); //false | true = true
System.out.println((a < b) | (a > c)); //true | false = true
System.out.println((a < b) | (a < c)); //true | true = true
System.out.println("---------------");

//^逻辑异或
System.out.println((a > b) ^ (a > c)); //false ^ false = false
System.out.println((a > b) ^ (a < c)); //false ^ true = true
System.out.println((a < b) ^ (a > c)); //true ^ false = true
System.out.println((a < b) ^ (a < c)); //true ^ true = false
System.out.println("---------------");

//!逻辑非
System.out.println(!(a > b)); //!false = true
System.out.println(!(a < b)); //!true = false
System.out.println(!!(a > b)); //!!false = false
System.out.println(!!!(a > b)); //!!false = true
}
}

位运算符

<<  左移位
>>  右移位
>>> 无符号右移位
public class OperatorDemo
{
public static void main (String args [])
{
int a = 3 >> 2;
int b = 3 >> 2;
int x = -3 >> 2;
int y = -3 >>> 2;
System.out.println(a);
System.out.println(b);
System.out.println(x);
System.out.println(y);
}
}
运行结果为：0 0 -1 1073741823
对于正数来说没有任何区别。
-3的补码进行右移两位运算
11111111-11111111-11111111-11111101
11111111-11111111-11111111-1111111101
右移两位之后加上两位符号位11
-3的补码进行无符号右移两位运算
11111111-11111111-11111111-11111101
00111111-11111111-11111111-1111111101
右移两位之后用00补位

& 按位与

| 按位或

^ 异或（相同为0，相反为1）

三元运算符

格式：（条件表达式）？表达式1：表达式2；

特点：三个元素参与的运算

如果条件为true，输出表达式1，条件为false，输出表达式2

class OperatorDemo {
public static void main(String[] args) {
int x = 100;
int y = 200;
int z = ((x > y)? x: y);
System.out.println("z:"+z);
}
}

流程控制语句句

顺序结构：从上往下，依次执行

class ShunXuJieGouDemo {
public static void main(String[] args) {
System.out.println("程序开始了");

System.out.println("我爱Java");

System.out.println("程序结束了");
}
}

选择结构：按照不同的选择，执行不同的代码

if语句

三种格式

if（条件表达式）｛执行语句：｝if后面如果没有｛｝，则只执行离他最近的单条语句

if（条件表达式）｛执行语句：｝else｛执行语句：｝

if else 结构 简写格式： 变量 = （条件表达式）？表达式1：表达式2

三元运算符 好处：可以简化if else 代码。 弊端：因为是一个运算符，所以运算完必须要有一个结果

if（条件表达式）｛执行语句：｝else if（条件表达式）｛执行语句：｝….else｛执行语句：｝ 循环结构：做一些重复的代码

if语句的注意事项：

A:比较表达式无论简单还是复杂，结果必须是boolean类型

B:if语句控制的语句体如果是一条语句，大括号可以省略；如果是多条语句，就不能省略。建议永远不要省略。

C:一般来说：有左大括号就没有分号，有分号就没有左大括号

Switch语句

格式：

switch（表达式）

switch（表达式）
｛
case 取值1：
执行语句；
break；
case 取值2：
执行语句；
break；
。。。。
default：
执行语句；
break；
｝

格式的解释：

switch:表示这是switch选择结构

表达式:这个地方的取值是有限定的

byte,short,int,char

JDK5以后可以是枚举

JDK7以后可以是字符串

case:后面跟的是要和表达式进行比较的值

语句体:要执行的代码

break:表示中断，结束的意思，可以控制switch语句的结束。

default:当所有的值都和表达式不匹配的时候，就执行default控制的语句。其实它就相当于if语句的else。

switch语句的注意事项：

A:case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的

B:default可以省略吗?

可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。

特殊情况：

case就可以把值固定。

A,B,C,D

C:break可以省略吗?

可以省略，但是结果可能不是我们想要的。

会出现一个现象：case穿透。

最终我们建议不要省略

D:default一定要在最后吗?

不是，可以在任意位置。但是建议在最后。

E:switch语句的结束条件

a:遇到break就结束了

b:执行到末尾就结束了

循环语句

for

/*
for循环格式：
for(初始化语句;判断条件语句;控制条件语句) {
循环体语句;
}
执行流程：
A:执行初始化语句
B:执行判断条件语句,看其返回值是true还是false
如果是true，就继续执行
如果是false，就结束循环
C:执行循环体语句;
D:执行控制条件语句
E:回到B继续。

注意事项：
A:判断条件语句无论简单还是复杂结果是boolean类型。
B:循环体语句如果是一条语句，大括号可以省略；如果是多条语句，大括号不能省略。建议永远不要省略。
C:一般来说：有左大括号就没有分号，有分号就没有左大括号

需求：请在控制台输出10次"HelloWorld"
*/
class ForDemo {
public static void main(String[] args) {

for(int x=1;x<=10;x++) {
System.out.println("HelloWorld");
}
}
}

While

/*
while循环的基本格式：
while(判断条件语句) {
循环体语句;
}

扩展格式：

初始化语句;
while(判断条件语句) {
循环体语句;
控制条件语句;
}

通过这个格式，我们就可以看到其实和for循环是差不多的。

for(初始化语句;判断条件语句;控制条件语句) {
循环体语句;
}
*/
class WhileDemo {
public static void main(String[] args) {
//输出10次"HelloWorld"
int x=0;
while(x<10) {
System.out.println("HelloWorld");
x++;
}

}
}

do…while

/*
do...while循环的基本格式：
do {
循环体语句;
}while(判断条件语句);

扩展格式；
初始化语句;
do {
循环体语句;
控制条件语句;
}while(判断条件语句);
*/
class DoWhileDemo {
public static void main(String[] args) {
//输出10次HelloWorld。
int x = 0;
do {
System.out.println("HelloWorld");
x++;
}while(x<10);

System.out.println("--------------");

//求和1-100
int sum = 0;
int a = 1;
do {
sum += a;
a++;
}while(a<=100);

System.out.println(sum);
}
}

控制跳转语句

break：中断的意思，跳出单层循环，用在循环和switch语句中，离开此应用场景无意义。

continue：继续，跳出单层循环的一次，可以继续下一次，用在循环中，离开此应用场景无意义。

return:返回， 用于结束方法的，一旦遇到return,程序就不会在继续往后执行。

方法（函数）

定义：函数就是定义在类中的具有特定功能的一段独立小程序，也称之为方法

格式：

修饰符 返回值类型 函数名（参数类型 形式参数1，参数类型 形式参数2….）

{

执行语句；

return 返回值；

}

返回值类型：函数运行后的结果的数据类型

参数类型：是形式参数的数据类型

形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数

实际参数：传递给形式参数的具体数值

return：用于结束函数

返回值：该值会反悔给调用者

定义方法需要两个明确：

返回值类型：结果的数据类型

参数列表：参数的个数及对应的数据类型

方法重载：

在同一个类中，方法名相同，参数列表不同。与返回值无关。

参数列表不同：参数的个数不同，参数的对应的数据类型不同。

数组

一维数组

定义：同一种类型数据的集合。其实数组就是一个容器。

好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。

格式

1.元素类型[] 数组名 = new 元素类型[元素个数或数组长度]；

2.元素类型[] 数组名 = new 元素类型[]{元素，元素，……};

数组中有一个属性可以直接获取到数组元素个数：length

数组的遍历

class ArrayTest {
public static void main(String[] args) {
//定义数组
int[] arr = {11,22,33,44,55};

//获取每一个元素
printArray(arr);

public static void printArray(int[] arr) {
System.out.print("[");
for(int x=0; x<arr.length; x++) {
if(x == arr.length-1) { //这是最后一个元素
System.out.println(arr[x]+"]");
}else {
System.out.print(arr[x]+", ");
}
}
}
}

二维数组

元素是一维数组的数组。

格式1：

数据类型[][] 数组名 = new 数据类型[m]
;

m:表示这个二维数组有多少个一维数组。

n:表示每一个一维数组的元素有多少个。

格式2：

数据类型[][] 数组名 = new 数据类型[m][];

m:表示这个二维数组有多少个一维数组。

列数没有给出，可以动态的给。这一次是一个变化的列数。

格式3：

数据类型[][] 数组名 = {{元素1,元素2…},{元素1,元素2…},{元素1,元素2…}};

举例：

int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};

int[][] arr = {{1,2,3},{4,5},{6}};

二维数组的遍历

class Array2Test
{
public static void main(String[] args)
{
//定义二维数组
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};

//遍历数组
printArry(arr);
}

public static void printArry(int[][] arr)
{
for (int x=0;x<arr.length ;x++ )
{
for (int y=0;y<arr[x].length ;y++ )
{
System.out.print(arr[x][y]+" ");
}
System.out.println();
}
}
}

总结

这篇博客主要讲述了Java的基础知识，这都是以后写程序的基石，以后不管学的知识再高深，也都离不开这些。所以，学Java，这些基础必须得深深地印在脑中。

——- android培训、java培训、期待与您交流！ ———-