------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------1.什么是JRE和JDK
JRE是java程序的运行环境，java运行的所需的类库+JVM(java虚拟机)
JDK是java的开发和运行环境，java的开发工具和jre
简单说,如果只需要运行java程序,只需装JRE即可,但如果要开发编写程序,必须装JDK
2.环境变量的配置
目的: path环境变量可以在任意的目录下,我们都可以执行指定的exe程序,如JDK中的编译工具javac.而classpath环境变量,可以在任意的目录下,引用其他目录下的class文件
2.1path环境变量
特点:系统默认先去当前路径下找要执行的程序，如果没有，再去path中设置的路径下找。
永久配置方式：JAVA_HOME=%安装路径%\Java\jdk
临时配置方式：set path=%path%;C:\ProgramFiles\Java\jdk\bin
2.2classpath环境变量
永久配置方式：classpath=.;c:\;e:\
临时配置方式：set classpath=.;c:\;e:\
2.3在定义classpath环境变量时，需要注意的情况
如果没有定义环境变量classpath，java启动jvm后，会在当前目录下查找要运行的类文件；如果指定了classpath，那么会在指定的目录下查找要运行的类文件。
3.java语法基础
3.1基本概念
关键字：其实就是某种语言赋予了特殊含义的单词。
标示符：其实就是在程序中自定义的名词
常量：是在程序中的不会变化的数据。
变量：其实就是内存中的一个存储空间，用于存储常量数据。
作用：方便于运算。因为有些数据不确定。所以确定该数据的名词和存储空间。
特点：变量空间可以重复使用。
变量的作用域和生存期:
变量的作用域：
作用域从变量定义的位置开始，到该变量所在的那对大括号结束；
生命周期：
变量从定义的位置开始就在内存中活了；
变量到达它所在的作用域的时候就在内存中消失了；
3.2数据类型：
3.2.1基本数据类型：byte、short、int、long、float、double、char、boolean
3.2.2引用数据类型: 数组、类、接口。
3.3运算符号：
3.3.1算术运算符。
+ - * / % %:任何整数模2不是0就是1，所以只要改变被模数就可以实现开关运算。
+:连接符。
++,--
3.3.2赋值运算符。
= += -= *= /= %=
3.3.3比较运算符。
特点：该运算符的特点是：运算完的结果，要么是true，要么是false。
3.3.4逻辑运算符。
& | ^ ! && ||
逻辑运算符除了 ! 外都是用于连接两个boolean类型表达式。
&: 只有两边都为true结果是true。否则就是false。
|:只要两边都为false结果是false，否则就是true
^:异或：和或有点不一样。
两边结果一样，就为false。
两边结果不一样，就为true.
& 和 &&区别： & ：无论左边结果是什么，右边都参与运算。
&&:短路与，如果左边为false，那么右边不参数与运算。
| 和|| 区别：|：两边都运算。
||：短路或，如果左边为true，那么右边不参与运算。
3.3.5位运算符:用于操作二进制位的运算符。
& | ^
<< >> >>>(无符号右移)
package Demoes;
public class Demo2 {
/**
* @param args
*/
public static void main(String[] args) {
// 面试题:
byte b = 4;
// 下面这句编译成功
// 原因:由于3和7都是int类型常量,相加后的结果为10,而10在byte的范围内,编译器会将10转换为byte类型,然后赋值给b,所以不报错
// b= 3+7;
byte b1 = 3;
byte b2 = 7;
// 下面这句编译失败
// 原因:由于b1和b2是变量,它的值是不确定的,相加后可能不在byte的范围内,会丢失精度,所以报错
// b = b1 + b2;
int x;
// 下面这句编译成功
// 原因:两个byte类型值相加后,一定会在int类型的范围内,所以不会编译错误
// x = b1 + b2;
int x1 = Integer.MAX_VALUE;
int x2 = 1;
x = x1 + x2;
System.out.println(x);
}
public static void eg2() {
// int x = 3;
// short b = 5;
// System.out.println(x + b);
// 强制类型转换
// byte b = 3;
// b = (byte) (b + 4);
System.out.println((char) ('a' + 1));
System.out.println('0' + 0);
}
public static void eg1() {
// 定义变量:
// 数据类型 变量名 = 初始化值;
byte b = 3;
}
}package Demoes;
public class Demo2 {
/**
* @param args
*/
public static void main(String[] args) {
// 以最有效的方式计算出2乘以8等于几?
// System.out.println(2 << 3);
// 对两个整数变量的值进行变换
int a = 3, b = 5;
// 方法一
// int temp = a;
// a = b;
// b = temp;
// 方法二
// a = b + (b = a) * 0;
// 方法三:这种方式不要用,如果两个整数的数值过大,会超出int范围,会强制转换,数据会发生变化
// a = a + b;
// b = a - b;
// a = a - b;
// 方法四
a = a ^ b;
b = a ^ b;
a = a ^ b;
System.out.println("a=" + a + ",b=" + b);
}
}3.4break语句和continue语句
break:作用于switch ，和循环语句，用于跳出，或者称为结束。
break语句单独存在时，下面不要定义其他语句，因为执行不到，编译会失败。
当循环嵌套时，break只跳出当前所在循环。要跳出嵌套中的外部循环，只要给循环起名字即可，这个名字称之为标号。
continue:只作用于循环结构，继续循环用的。
作用：结束本次循环，继续下次循环。该语句单独存在时，下面不可以定义语句，执行不到。
package forDemos;
public class Demo2 {
/**
* @param args
*/
public static void main(String[] args) {
// break:跳出
// break作用范围:要么是switch语句,要么是循环语句
// 记住:当break语句单独存在时,下面不要定义其他语句,因为执行不到
// break跳出当前循环
// for (int i = 0; i < 3; i++) {
// System.out.println("i=" + i);
// break;
// }
// xiaoqiang: for (int x = 0; x < 3; x++) {
// wangcai: for (int y = 0; y < 4; y++) {
// System.out.println("x=" + x);
// break xiaoqiang;
// }
// }
// continue:继续
// 作用的范围:循环结构
// continue:结束本次循环,继续下次循环
// 记住:当continue语句单独存在时,下面不要定义其他语句,因为执行不到
for (int x = 0; x < 3; x++) {
System.out.println("x=" + x);
continue;
}
}
}3.5函 数：为了提高代码的复用性，可以将其定义成一个单独的功能，该功能的体现就是java中的函数。函数就是体现之一。
java中的函数的定义格式：
修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数1，…){
执行语句；
return 返回值；
}
当函数没有具体的返回值时，返回的返回值类型用void关键字表示。
如果函数的返回值类型是void时，return语句可以省略不写的，系统会帮你自动加上。
return的作用：结束函数。结束功能。
函数的作用：
1）、用于定义功能。
2）、用于封装代码提高代码的复用性。
注意：函数中只能调用函数，不能定义函数。
主函数：
1）、保证该类的独立运行。
2）、因为它是程序的入口。
3）、因为它在被jvm调用。
函数定义名称是为什么呢？
答：1）、为了对该功能进行标示，方便于调用。
2）、为了通过名称就可以明确函数的功能，为了增加代码的阅读性。
package funcDemoes;
public class Demo1 {
/**
* @param args
*/
public static void main(String[] args) {
// int a = 3;
// int b = 4;
// int c;
// c = a + b;
int c = add(3, 4);
System.out.println("c=" + c);
// 定义函数的格式:
// 修饰符 返回值类型 函数名(参数类型 形式参数1,参数类型 形式参数2,...){
// 执行语句;
// return 返回值;
// }
// 特殊情况:功能没有具体的返回值
// 这时return的后面直接用分号结束
// 返回值类型怎么体现呢?因为没有具体指,所以不可以写具体的数据类型
// 在java中只能用一个关键字来表示这种情况,关键字是void
}
public static int add(int a, int b) {
return a + b;
}
public static void myPrint() {
System.out.println("hello world");
}
}
package funcDemoes;
public class Demo2 {
/**
* @param args
*/
public static void main(String[] args) {
print99();
}
// 需求1:定义一个功能,完成两个整数的和的获取
// 思路:既然定义功能,就是可以用函数来体现.
// 如何定义一个函数呢?
// 通过两个明确来完成
// 明确一:这个功能的结果是什么?是和.是功能的结果,所以该功能的返回值类型是int.其实就是在明确函数的返回值类型
// 明确二:这个功实现过程中是否需要未知内容参与运算?有,加数和被加数.这就是函数的参数列表(参数的个数,参数的类型).其实就是明确参数列表
// 注意:返回值类型和参数类型没有直接的关系
public static int add(int a, int b) {
return a + b;
}
// 需求2:定义一个功能,画一个矩形
// 明确一:这个功能的结果是什么?没有结果,因为直接打印到了控制台上,并没有返回给调用者,用void表示
// 明确二:这个功实现过程中是否需要未知内容参与运算?有,行和列不确定.两个,整数int
public static void draw(int row, int col) {
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
System.out.print("*");
}
System.out.println();
}
// return; // 可以省略不写
}
// 需求3:定义一个功能,比较两个数是否相等
// 明确一:这个功能的结果是什么?有,boolean
// 明确二:这个功实现过程中是否需要未知内容参与运算?有,两个整数
public static boolean equals(int a, int b) {
return a == b;
}
// 需求4:定义一个功能,获取两个整数中较大的那个数
// 明确一:这个功能的结果是什么?有,其中一个数.int
// 明确二:这个功实现过程中是否需要未知内容参与运算?有,参与比较的两个整数int
public static int getMax(int a, int b) {
return a > b ? a : b;
}
// 定义功能,打印9*9乘法表
public static void print99() {
for (int x = 1; x <= 9; x++) {
for (int y = 1; y <= x; y++) {
System.out.print(y + "*" + x + "=" + (y * x) + "\t");
}
System.out.println();
}
}
// 根据考试成绩获取学生分数对应的等级
public static char getScore(int score) {
switch (score / 10) {
case 10:
case 9:
return 'A';
case 8:
return 'B';
case 7:
return 'C';
case 6:
return 'D';
default:
return 'E';
}
}
}如何区分重载：当函数同名时，只看参数列表。和返回值类型没关系。
package funcDemoes;
/**
* 需求:函数的重载
*
* @author Administrator
*
*/
public class Demo3 {
/**
* @param args
*/
public static void main(String[] args) {
printCFB(5);
}
// 函数的重载
// 1.同一个类
// 2.同名
// 3.参数的个数不同或者参数的类型不同
// 4.函数重载和返回值无关
// 5.java是严谨性语言,如果函数出现的调用不确定性,则函数调用失败,程序出错
// 加法运算.两个整数的和
public static int add(int a, int b) {
return a + b;
}
// 加法运算,两个小数的和
public static double add(double a, double b) {
return a + b;
}
// 加法运算,三个整数的和
public static int add(int a, int b, int c) {
return a + b + c;
}
// 打印乘法表
public static void printCFB(int num) {
for (int i = 1; i <= num; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(j + "*" + i + "=" + (i * j) + "\t");
}
System.out.println();
}
}
}3.8数 组：用于存储同一类型数据的一个容器。好处：可以对该容器中的数据进行编号，从0开始。数组用于封装数据，就是一个具体的实体。
如何在java中表现一个数组呢？两种表现形式。
1）、元素类型[] 变量名 = new 元素类型[元素的个数]；
2）、元素类型[] 变量名 = {元素1，元素2...}；
元素类型[] 变量名 = new 元素类型[]{元素1，元素2...}；
java分了5片内存。
1：寄存器。2：本地方法区。3：方法区。4：栈。5：堆。
栈：存储的都是局部变量 ( 函数中定义的变量，函数上的参数，语句中的变量 )；
只要数据运算完成所在的区域结束，该数据就会被释放。
堆：用于存储数组和对象，也就是实体。啥是实体啊？就是用于封装多个数据的。
1：每一个实体都有内存首地址值。
2：堆内存中的变量都有默认初始化值。因为数据类型不同，值也不一样。
3：垃圾回收机制。
package arrayDemoes;
public class Demo1 {
/**
* @param args
*/
public static void main(String[] args) {
// 数组
// 元素类型[] 数组名 = new 元素类型[元素的个数或数组的长度];
int[] arr = new int[3];
arr[0] = 89;
System.out.println(arr[0]);
for (int x = 0; x < 4; x++) {
System.out.println("x=" + x);
}
{
// 局部代码块.限定局部变量的生命周期
int age = 3;
}
}
// 内存的划分:
// 1.寄存器
// 2.本地方法区
// 3.方法区
// 4.栈内存
// 存储的都是局部变量
// 5.堆内存
// 存储是数组和对象(其实数组就是对象)方式new建立在堆中
// 特点:
// 1.每一个实体都有首地址值
// 2.堆内存中的每一个变量都有默认的初始化值,根据类型的不同而不同,整数是0,小数是0.0或者0.0f,boolean是false,char是'\u0000',其中u是Unicode码
}
扫一扫
474
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
