黑马程序员---java基础之day1-3
第一天：
Java语言的特点：跨平台性，java语言运行在JVM上，JVM充当了一个桥梁，使java语言能与不同的操作系统结合。
Java运行环境（Jre）：JVM和java核心类库。
Java开发工具包（Jdk）：包括java开发工具和运行环境（Jre）。
Dos命令行常见命令：
Dir：列出当前目录下的文件以及文件夹。
Md：创建目录。如md abc
Rd：删除目录。如rd abc 保证目录为空
Cd：进入指定目录。如cd jdk*
Cd..：退回到上一级目录。
Cd\：退回到根目录。
Del：删除文件。如del c:\a.exe
Exit：退出dos命令行。
Help：列出当前可用的所有命令。
Help[命令]：具体命令的使用方法。
Cls：清屏
环境变量的设置：
为了能让java中的命令在任何目录下都能使用，需要在系统中设置环境变量。
当我们用命令执行一个应用程序事，先在当前目录下找是否有该应用程序，如果没有，就在系统中设置的path环境变量的目录下寻找。
验证环境变量是否设置成功：在任意目录下使用path目录下的命令是否成功。
新建环境变量：hah=c:\javaJDK\jdk1.5 path=%haha%
临时环境变量的设置（命令行）：
set path：查看环境变量
临时设置（只在当前命令窗口有效）：set path=c:\....
在已有的环境变量添加新的（只在当前命令窗口有效）：set path=c:\jdk\bin;%path%
删除临时环境变量set path=
第一个java程序：
123.java：
classDemo
{
public static voidmain(String[] args)
{
System.out.println("helloE盘");
}
}
编译：当前java文件目录>javac 123.java
运行：当前类文件目录>java Demo
注意：类名中如果加了访问修饰符public，则文件名必须和类名相同，否则会报错
123.java:1: 错误: 类Demo是公共的, 应在名为Demo.java 的文件中声明
public class Demo
^
1 个错误
环境变量Classpath(类文件路径)的设置：
在当前目录下执行非当前目录下的字节码文件。
设置：Set classpath=c:\myclass （执行指定目录下的类文件，没指定则在当前目录下查找）
Setclasspath=c:\myclass;后面加了分号则先在当前目录下查找，如果没找到则在设置的目录下查找（建议不加分号）
Set classpath=.;classpath=c:\myclass 既在当前目录下查找，也在指定目录下查找。
第二天：
Java语言基础组成：
1、关键字
2、标识符：
①、在程序中自定义的一些名称。
②、由26个英文字母大小写，数字：0-9 ，符号：_ $ 组成
③、定义合法标识符规则：1，数字不可以开头2，不可以使用关键字
④、java中严格区分大小写。
⑤、注意：在起名字时，为了提高阅读性，要尽量有意义
3、注释：
①、用于注解说明程序的文字就是注释
②、提高了代码的阅读性
③、java中的注释格式：
单行注释：//注释文字
多行注释：/*注释文字*/
文档注释：/**
注释文字
*/
·对于单行和多行注释，被注释的文字不会被JVM解释执行。
·对于文档注释，是java特有的注释，其中注释内容可以被JDK提供
·的工具javadoc所解析，生成一套以网页文件形式体现的该程序的说明文档
·注释是一个程序员必须要具有的良好编程习惯
·初学者编写程序可以养成良好的习惯：先写注释再写代码
·将自己的思想通过注释先整理出来，再用代码去体现。
·因为代码仅仅是思想的一种体现形式而已
注释的应用：
/*
需求：练习一个hello world程序。
思路：
1，定义一个类，因为java程序都定义类中，java程序都是以类的形式存在的，类的形式其实就是一个字节码文件最终体现。
2，定义一个主函数。为了让该类可以独立运行。
3，因为演示hello world，在控制台上看到该字样，所以需要使用输出语句完成。
步骤：
1，用class关键字来完成类的定义，并起一个阅读性强的类名。
2，主函数：public staticvoid main(String[] args)这时固定格式的。jvm认识。
3，使用输出语句：System.out.println("helloworld");
代码仅仅是思想的一种体现形式。
*/
class Demo
{
//定义一个主函数，为了保证程序的独立运行。
public static voidmain(String[] args)
{
System.out.println("helloworld");//这是输出语句，用于将括号中的数据打印到控制台上，ln可以在数据的结尾处换行。
}
}
4、常量与变量
（1）、常量表示不能改变的值
（2）、java中常量的分类：
1，整数常量，所有整数
2，小数常量，所有小数
3，布尔（boolean）型常量，较为特有，只有两个数值。true false
4，字符常量，将一个数字字母或者符号用（’’）标识
5，字符串常量，将一个或者多个字符用双引号（” ”）标识
6，null 常量，只有一个数值就是null
(3)、对于整数，有四种表现形式。
1，二进制：0，1，满2进1
2，八进制：0-7，满8进1，用0开头表示
3，十进制：0-9，满10进1
4，十六进制：0-9，A-F，满16进1，用0x开头表示
（4）、进制的转换：
752=2*10(0)+5*10(1)+7*10(2)=752 (十进制转十进制)
1011=1*2(0)+1*2(1)+0*2(2)+1*2(3)=11（二进制转十进制）
010-101-110=0256（二进制转八进制，三位为一组）
1010-1110=0xAE（二进制转十六进制，四位为一组）
结论：八进制数，其实就是二进制位3个二进制位为一个八进制位
十六进制数，其实就是二进制位4个二进制位为一个十六进制位
负数的二进制表现形式：这个数的正数的二进制取反加1.
取反：0000-0110->1111-1001
(5)、变量的概念：
1，内存中的一个存储区域
2，该区域有自己的名称（变量名）和类型（数据类型）
3，该区域的数据可以在同一类型范围内不断变化
（6）、为什么要定义变量：
·用来不断的存储同一类型的常量，并可以重复使用
（7）、使用变量注意：
1，变量的作用范围（一对{}之间有效）
2，初始化值
（8）、定义变量的格式：
·数据类型 变量名=初始化值；
·注：格式是固定的，记住格式以不变应万变。
（9）、变量如同数学中的未知数。
数据类型：
Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间
数据类型演示：
class VarDemo
{
public static voidmain(String[] args)
{//数据类型 变量名 = 初始化值;
byte b = 3;
short s =4000;
int x =12;
long l =123l;
float f =2.3f;
double d =3.4;
char ch ='1';
boolean bl= true;
bl =false;
{
int z = 9;
System.out.println(z);
}
System.out.println(z);
//System.out.println(y);
}
}
classVarDemo2
{
public static voidmain(String[] args)
{
// intx = 3;
// byteb = 5;
// x = x + b;
//不同类型的数值型运算时自动类型提升byte型转换成int
// byteb = 3;
// b= (byte)(b + 200); // b+200中b的类型自动提升为int，再强制转换成byte类型会造成精度损失。Byte型一个字节，int型4个字节
//System.out.println((char)('a'+1)); //输出字符b
// System.out.println('你'+0);//unicode国际标准码表。
byte b = 4;
//b = 3+7; //正确，相当于b=10，10是常量，是固定值，可以判断是否超出范围
byte b1 = 3;
byte b2 = 7;
//b2 = 127;
int x;
//b = b1 + b2; //错误，b1与b2是变量，相加可能会超出byte范围，是不确定值，可能造成精度损失
int x1=Integer.MAX_VALUE ;
int x2 =2;
x = x1+x2; / /int是默认类型，超出范围也能运算
//System.out.println(x);
int n = 8;
n = 9;
n = 19;
//System.out.println(n);
}
}
·自动类型转换（也叫隐式类型转换）
·强制类型转换（也叫显式类型转换）
·类型转换的原理
·什么时候要使用强制类型转换？
·表达式的数据类型自动提升
·所有的byte型、short型和char的值将被提升到int型
·如果一个操作数是long型，计算结果就是long型
·如果一个操作数是float型，计算结果就是float型
·如果一个操作数是double型，计算结果就是double型
分析：
·system.out.println(‘a’)与system.out.println(‘a’+1)的区别
4，算数运算符
class OperateDemo
{
public static voidmain(String[] args)
{
//算术运算符。 + - * / %(取余，模运算) +(连接符)
// ++(自增：就在原有数据基础上+1，在赋给原有数据) --
//int x = 6370;
//x= x / 1000 * 1000;
//System.out.println(x);
// System.out.println(5%2);
// System.out.println(3+"2");//结果是字符串”32”
//System.out.println("5+5="+(5+5));//"5+5=5"+5"5+5=55"
//inta = 4,b = 5;
//System.out.println("a="+a+",b="+b);//a=4,b=5;
int a = 3,b;
//a++;//a = a+1;
// b= a++; //内存中是先右边运算完再赋给左边，先把a原来的值预存，接着a自增运算，最后再把a预存的值赋给b（重要）
//b=++a;// 右边a先做自增运算，再把自增后的结果赋给b
b =(a++)+(++a)+(a++)+a;
// 3 5 5 6
System.out.println("a="+a+",b="+b);
int i = 3;
i = i++;
System.out.println("i="+i);//结果是3，i先把原来的值3预存，接着做自增运算为4，最后把预存的值3赋给i
}
}
5，赋值运算符
class OperateDemo2
{
public static voidmain(String[] args)
{
//赋值运算符。= += -=*= /= %=
// inta,b,c;
// a= b = c = 4;
//int a = 4;
//a+=2;//a= a + 2;
short s = 3;
//s+=4; //相当于s= (short)(s + 4);在底层做了自动转换的动作
s = s + 4;//错误s是变量，是不确定值，可能会损失精度
System.out.println("s="+s);
}
}
第三天：
6、比较运算符、逻辑运算符
class OperateDemo3
{
public static voidmain(String[] args)
{
/*
比较运算符，运算完的结果必须是true或者false。
*/
// System.out.println(3>2);//true
// System.out.println(3==2);//false
// 2
/*
逻辑运算符有什么用？
用于连接两个boolean类型的表达式。
&:与
|:或
&:符号的运算特点：
true& true = true;
true& false = false;
false& true = false;
false& false = false;
&:运算规律：
&运算的两边只有有一个是false，结果肯定是false。
只有两边都为true，结果才是true。
|:运算特点：
true| true = true;
true| false = true;
false| true = true;
false| false = false;
|:运算规律：
|运算的两边只要有一个是true，结果肯定是true。
只有两边都为false。结果是false。
^:异或：和或有点不一样。
^:运算特点。
true^ true = false;
true^ false = true;
false^ true = true;
false^ false = false;
^异或的运算规律：
^符号的两边结果如果相同，结果是false。
两边的结果不同，结果是true。
!:非运算，判断事物的另一面。
!true= false
!false= true;
!!true= true;
面试题：
&&:
和&运算的结果是一样的。但是运算过程有点小区别。
&：无论左边的运算结果是什么，右边都参与运算。
&&：当左边为false时，右边不参与运算的。
||:
和|运算的结果是一样的。但是运算过程有点小区别。
|：无论左边的运算结果是什么，右边都参与运算。
||：当左边为true时，右边不参与运算的。
*/
int x = 1;
// System.out.println(x>2&x<5);
// System.out.println(x<2|x>5);
// x>2&& x<5
}
}
7，位运算符：
| 位运算符 |
||
| 运算符 |
运算 |
范例 |
| << |
左移 |
3<<2=12 => 3*2*2=12 |
| >> |
右移 |
3>>1=1 => 3/2=1 |
| >>> |
无符号右移 |
3>>>1=1 => 3/2=1 |
| & |
与运算 |
6&3=2 |
| | |
或运算 |
6|3=7 |
| ^ |
异或运算 |
6^3=5 |
| ~ |
反码 |
~6=3 |
位运算是直接对二进制进行运算
class OperateDemo4
{
public static voidmain(String[] args)
{
// System.out.println(6&3);
// System.out.println(6|3);
// System.out.println(~6);
System.out.println(3<<2);//3左移两位。
//<<:左移几位其实就是该数据乘以2的几次方。
//>>:右移几位，其实就是该数据除以2的几次幂。对于高位出现的空位，原来高位是什么就用什么补这个空位
//>>>:无符号右移，数据进行右移时，高位出现的空位，无论是什么，都用0补
}
}
class OperateTest2
{
public static voidmain(String[] args)
{
/*
对一个整数的最后一个字节，高四位和低四位进行换位。
intnum = 0101-1100 & 255;
1100-0101
61= 0011-1101
1101-0011 = 211
*/
int num = 61;
int n1 = num& 15;//低四位
int n2 = num& (15<<4);//高四位
int n =n1<<4 | n2>>>4;
System.out.println("n="+n);
}
}
位运算练习：
class OperateTest
{
public static voidmain(String[] args)
{
//最有效率的方式算出2乘以8等于几？
2*8=2*2(3) => 2<<3
计算机底层：
0010
*1000
--------------
0000
0000
0000
0010
----------
10000
// System.out.println(2<<3);
// 对两个整数变量的值进行互换 (不需要第三方变量)
int a = 3,b = 5;
System.out.println("a="+a+",b="+b);
/*
开发时，使用第三方变量的形式，因为阅读性强。
intc ;
c= a;
a= b;
b= c;
*/
//这种方式不要用，如果两个整数的数值过大，会超出int范围，会强制转换。数据会变化。
/*
a= a + b; //a = 3 + 5;a = 8;
b= a - b; //3+5-5 = 3;b = 3;
a= a - b; //3+5-3 = 5;a = 5;
*/
/*
面试的时候用。
a= a ^ b; //a = 3 ^ 5;
b= a ^ b; //b = (3^5)^5; b = 3;
a= a ^ b; //a = (3^5)^3; a = 5;
*/
System.out.println("a="+a+",b="+b);
}
}
8，三元运算符
class OperateDemo5
{
public static voidmain(String[] args)
{
int x = 0,y;
y =(x>1)?100:200;
System.out.println("y="+y);
//获取两个整数中的较大的整数。
int a,b;
int max =a>b?a:b;
//获取三个整数中的较大的整数。
int o,p,q;
int temp =o>p?o:p;
int max2 =temp>q?temp:q;
}
}
9，程序流程控制：
·判断结构
·选择结构
·循环结构
判断结构：
class IfDemo
{
public static voidmain(String[] args)
{
/*
if语句的第一种格式：
1，
if(条件表达式)
{
执行语句；
}
*/
int x = 1;
if(x>1)
{
if(x<2)
{
System.out.println("yes");
}
}
System.out.println("over");
}
}
class IfDemo2
{
public static voidmain(String[] args)
{
/*
if语句的第二种格式：
if(条件表达式)
{
执行语句；
}
else//否则
{
执行语句；
}
*/
int x = 1;
if(x>1)
{
System.out.println("yes");
}
else
{
System.out.println("no");
}
System.out.println("HelloWorld!");
int a = 3,b;
/*
if(a>1)
b= 100;
else
b= 200;
*/
b =a>1?100:200;//三元运算符就是if else语句简写格式。
// 简写格式什么时候用？
// 当ifelse运算后，有一个具体的结果时，可以简化写成三元运算符。
System.out.println("b="+b);
}
class IfDemo3
{
public static voidmain(String[] args)
{
{//局部代码块可以定义局部变量的生命周期。
int a = 3;
//a 的运算。
System.out.println(a+4);
}
/*
if语句第三种格式：
if(条件表达式)
{
执行语句；
}
elseif (条件表达式)
{
执行语句；
}
……
else
{
执行语句；
}
*/
int x = 3;
if(x>1)
System.out.println("a");
else if(x>2)
System.out.println("b");
else if(x>3)
System.out.println("c");
else
System.out.println("d");
int y = 3;
if(y>1)
System.out.println("a1");
if(y>2)
System.out.println("b1");
if(y>3)
System.out.println("c1");
else
System.out.println("d1");
if(x==1)
if(y==1)
System.out.println("a");
else
System.out.println("b");
else
if(y==1)
System.out.println("c");
else
System.out.println("d");
// if(false);
{//局部代码块。
int m =89;
System.out.println("HelloWorld!..."+m);
}
System.out.println("over....."+m);
}
}
class IfTest
{
public static voidmain(String[] args)
{
/*
需求：根据用户指定的具体数据，判断该数据对应的星期。
1-星期一Monday
思路：
用户输入无法获取但是那只是具体数据的一种获取手段而已。
而我们要做的功能仅仅是对用户指定的数据进行对应星期的打印而已。
所以具体的数据不确定，完成可以使用变量来表示。
我们只对变量进行操作即可。至于变量的值，可以有用户决定。
因为数据的不确定性，所以要对数据进行判断。
使用if语句。
*/
int week = 10;
if(week==1)
System.out.println(week+"对应中文是星期一");
else if(week==2)
System.out.println(week+"对应中文是星期二");
else if(week==3)
System.out.println(week+"对应中文是星期三");
else if(week==4)
System.out.println(week+"对应中文是星期四");
else if(week==5)
System.out.println(week+"对应中文是星期五");
else if(week==6)
System.out.println(week+"对应中文是星期六");
else if(week==7)
System.out.println(week+"对应中文是星期日");
else
System.out.println(week+"没有对应的星期");
}
}
class IfTest2
{
public static voidmain(String[] args)
{
/*
一年有四季。
春季：34 5
夏季：67 8
秋季：910 11
冬季：121 2
根据用户输入的月份，给出对应的季节。
*/
int month = 8;
if(month<1 ||month>12)
System.out.println(month+"月没有对应的季节");
elseif(month>=3 && month<=5)
System.out.println(month+"月是春季");
elseif(month>=6 && month<=8)
System.out.println(month+"月是夏季");
elseif(month>=9 && month<=11)
System.out.println(month+"月是秋季");
else
System.out.println(month+"月是冬季");
/*
if(month==3|| month==4 || month==5)
System.out.println(month+"月是春季");
elseif(month==6 || month==7 || month==8)
System.out.println(month+"月是夏季");
elseif(month==9 || month==10 || month==11)
System.out.println(month+"月是秋季");
elseif(month==12 || month==1 || month==2)
System.out.println(month+"月是冬季");
else
System.out.println(month+"月没有对应的季节");
*/
}
}
选择结构：
class SwitchDemo
{
public static voidmain(String[] args)
{
/*
switch(表达式)
{
case取值1:
执行语句；
break；
case取值2:
执行语句；
break；
…...
default:
执行语句；
break；
}
*/
int x = 2;
switch(x)//byte,short,int,char.
{
default:
System.out.println("d");
//break;
case 4:
System.out.println("a");
//break;
case 1:
System.out.println("b");
break;
case 3:
System.out.println("c");
break;
}
int a = 4,b =2;
char opr = '%';
switch(opr)
{
case '+':
System.out.println(a+b);
break;
case '-':
System.out.println(a-b);
break;
case '*':
System.out.println(a*b);
break;
case '/':
System.out.println(a/b);
break;
default:
System.out.println("无法运算,符号不支持");
break;
}
}
}
class SwitchTest
{
public static voidmain(String[] args)
{
/*
用户输入的数据对应的出星期。
*/
int week = 1;
switch(week)
{
default:
break;
case 1:
System.out.println(week+"对应的是星期一");
break;
case 2:
System.out.println(week+"对应的是星期二");
//break;
//...以此类推。
}
/*
季节的示例。
*/
int month = 13;
switch(month)
{
case 3:
case 4:
case 5:
System.out.println(month+"月对应的是春季");
break;
case 6:
case 7:
case 8:
System.out.println(month+"月对应的是夏季");
break;
case 9:
case 10:
case 11:
System.out.println(month+"月对应的是秋季");
break;
case 12:
case 1:
case 2:
System.out.println(month+"月对应的是冬季");
break;
default:
System.out.println(month+"月没有对应的季节");
//break;
}
// System.out.println("HelloWorld!");
}
}
If和switch的应用场景：
if:
1,对具体的值进行判断。
2,对区间判断。
3,对运算结果是boolean类型的表达式进行判断。
switch:
1,对具体的值进行判断。
2,值的个数通常是固定的。
对于几个固定的值判断，建议使用switch语句，因为switch语句会将具体的答案都加载进内存。
效率相对高一点。
循环结构：
class WhileDemo
{
public static voidmain(String[] args)
{
/*
while(条件表达式)
{
执行语句；
}
*/
int x = 1;
while(x<3);
{
System.out.println("x="+x);
x++;
}
}
}
class WhileTest
{
public static voidmain(String[] args)
{
/*
练习：
获取1到1010个数字的和。
0+ 1
1+ 2
3 + 3
6 + 4
10 + 5
思路：
1，每次参与加法的数值不确定。
2，每次的出现的和数据也不确定。
3，发现参与加法运算的数值有递增规律。
4，每一次都是加法运算在重复，并且都是和再加上下一个数值。
步骤：
1，定义一个变量，记录住参与加法运算的数据。
2，定义一个变量，记录中每一次的出现的和。
3，对于记录参与加法运算的数据进行自增。
4，因为加法运算需要重复，就要想到循环结构。
*/
//累加思想。
int x = 1;//记录参与加法的数据。
int sum = 0;//记录住每一次的和。
while(x<=100)
{
sum = sum+ x;
x++;
}
System.out.println("sum="+sum);
}
}
class WhileTest2
{
public static voidmain(String[] args)
{
/*
练习：
1~100之间6的倍数出现的次数。
要求：自己独立完成思想的书写。和步骤的文字描述。
*/
// 计数器思想
int x = 1;
int count = 0;
while(x<=100) //循环条件
{
if(x%6==0)
count++;
// System.out.println("x="+x);
x++; //控制循环次数
}
System.out.println("count="+count);
}
}
class DoWhileDemo
{
public static voidmain(String[] args)
{
/*
do
{
执行语句；
}while(条件表达式);
*/
int x = 1;
do
{
System.out.println("x="+x);
x++;
}
while (x<1);
/*
dowhile语句的特点：无论条件是否满足，循环体至少执行一次。
*/
int y = 1;
while(y<1)
{
System.out.println("y="+y);
y++;
}
}
}
class ForDemo
{
public static voidmain(String[] args)
{
/*
for(初始化表达式；循环条件表达式；循环后的操作表达式)
{
执行语句；(循环体)
}
for(intx = 1; x<3; x++)
{
System.out.println("x="+x);
}
*/
int x = 1;
for(System.out.println("a");x<3;System.out.println("c"))
{
System.out.println("d");
x++;
}
// for(inta=0,b=0; a<3; a++,b--)
//ad c d c
}
}
class ForTest
{
public static voidmain(String[] args)
{
/*
用for完成累加。
*/
int sum = 0;
for(int x=1;x<=10; x++)
{
sum = sum+ x;
}
System.out.println("sum="+sum);
/*
for和while的特点：
1,for和while可以互换。
2,格式上的不同，在使用上有点小区别。
如果需要通过变量来对循环进行控制，该变量只作为循环增量存在时，区别就体现出来了。
*/
//打印1~10十个数字
int x = 1;
while(x<5)
{
System.out.println("x="+x);
x++;
}
System.out.println("x===="+x);
for(int y=1;y<5; y++)
{
System.out.println("y="+y);
}
System.out.println("y====="+y);
//无限循环最简单的形式。
// while(true){}
// for(;;){}
什么时候使用循环结构呢？
当对某些代码执行很多次时，使用循环结构完成。
当对一个条件进行一次判断时，可以使用if语句。
当对一个条件进行多次判断时，可以使用while语句。
注意：
在使用循环时，一定要明确哪些语句需要参与循环，哪些不需要。
循环通常情况下，需要定义条件，需要控制次数。
}
}