1 Java第二课
1.1 回顾:
1. java发展历史,95 09 ,java平台:javaSE(标准版) javaEE(企业版) javaME(微型版)
2. Java语言的特点:面向对象,跨平台(字节码文件->不同的平台上有不同的虚拟机,虚拟机解释字节码文件),健壮性(强类型,取消指针,不用强制回收对象),分布式,多线程,动态性等
3. Jdk,jre jvm三者关系 (jdk>jre>jvm)
4. Jdk的安装和环境配置
5. IDE工具Eclipse: 工具的配置与使用
6. Java基本语法:
package day01;
public class 类名{
public static void main(String[] args){
System.out.println(“内容~”);
}
}
7. java代码的执行过程: .java 编译 字节码文件.class 执行->结果
1.2 Java基础结构
1.2.1 包 package相当于目录
导包方式在类的第一行 : package 包路径;
包的分级要用.;
1.2.2 类
基本结构:
创建一个类:
class 类名{
开始写代码
}
1.class类:类是java程序的基本结构
2.class类名命名规则:首字母大写(不大写也不会报错,但默认都是大写)
3.类里面包含多个方法.要看到运行结果必须有main方法
4.方法用来存放要运行的语句
5.每一个语句要以分号为结束
6.java程序创建类的规则:
① java文件可以有多个class
② 但是被public修饰的类只能有一个
③ 被public修饰的类的类名必须和java文件的文件名一致
④ 语句一定要写在方法里面
⑤ java程序的入口是main()
⑥ 包的概念:相当于一个文件夹,同一个包下java文件名不能重复,不同包下的java文件名可以重复
控制台的输出语句:
System.out.println(); 换行输出 ln-line
System.out.print(); 不换行输出
后面会说一下它们的区别
1.3 Java中的关键字:
Java的关键字对Java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等，关键字不能用作变量名、方法名、类名、包名和参数。如:package class void int等,这些都是java中已经定义好,我们自己定义变量,不能使用.(也可以理解为古代皇帝的名字普通人是不能取得的...)
这边百度了一下java 48个常用关键字以及它们的含义:
abstract：用于声明抽象类——可以有抽象和非抽象方法。
boolean：用于将变量声明为布尔值类型，它只有 true 和 false 两个值。
break：用于中断循环或 switch 语句。
byte：用于声明一个可以容纳 8 个比特的变量。
case：用于在 switch 语句中标记条件的值。
catch：用于捕获 try 语句中的异常。
char：用于声明一个可以容纳无符号 16 位比特的 Unicode 字符的变量。
class：用于声明一个类。
continue：用于继续下一个循环。它可以在指定条件下跳过其余代码。
default：用于指定 switch 语句中除去 case 条件之外的默认代码块。
do：通常和 while 关键字配合使用，do 后紧跟循环体。
double：用于声明一个可以容纳 64 位浮点数的变量。
else：用于指示 if 语句中的备用分支。
enum： enum（枚举）关键字用于定义一组固定的常量。
extends：用于指示一个类是从另一个类或接口继承的。
final：用于指示该变量是不可更改的。
finally：和 try-catch 配合使用，表示无论是否处理异常，总是执行 finally 块中的代码。
float：用于声明一个可以容纳 32 位浮点数的变量。
for：用于启动一个 for 循环，如果循环次数是固定的，建议使用 for 循环。
if：用于指定条件，如果条件为真，则执行对应代码。
implements：用于实现接口。
import：用于导入对应的类或者接口。
instanceof：用于判断对象是否属于某个类型（class）。
int：用于声明一个可以容纳 32 位带符号的整数变量。
interface：用于声明接口——只能具有抽象方法。
long： long 关键字用于声明一个可以容纳 64 位整数的变量。
native： native 关键字用于指定一个方法是通过调用本机接口（非 Java）实现的。
new： new 关键字用于创建一个新的对象。
null： 如果一个变量是空的（什么引用也没有指向），就可以将它赋值为 null。
package：用于声明类所在的包。
private：是一个访问修饰符，表示方法或变量只对当前类可见。
protected：也是一个访问修饰符，表示方法或变量对同一包内的类和所有子类可见。
public：是另外一个访问修饰符，除了可以声明方法和变量（所有类可见），还可以声明类。main() 方法必须声明为 public。
return： 用于在代码执行完成后返回（一个值）。
short： 用于声明一个可以容纳 16 位整数的变量。
static：表示该变量或方法是静态变量或静态方法。
strictfp：并不常见，通常用于修饰一个方法，确保方法体内的浮点数运算在每个平台上执行的结果相同。
super：可用于调用父类的方法或者变量。
switch：通常用于三个（以上）的条件判断。
synchronized：用于指定多线程代码中的同步方法、变量或者代码块。
this：可用于在方法或构造函数中引用当前对象。
throw：主动抛出异常。
throws： 用于声明异常。
transient：在序列化的使用用到，它修饰的字段不会被序列化。
try：用于包裹要捕获异常的代码块。
void：用于指定方法没有返回值。
volatile：保证了不同线程对它修饰的变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
while： 如果循环次数不固定，建议使用 while 循环。
注：
需要注意的是java中 true, false, null， goto, const 不是关键字, 是（Java保留字，它不用，你也不能用）
1.4 Java中的标识符，常量，变量:
标识符可以用来定义类，方法，变量等等，那么，这个标识符有哪些常见的规则：
1. 标识符应该由字母 数字 下划线和$符号组成;
2. 不能以数字开头;
3. 要有一定含义,尽量遵循骆驼命名的方法，第一个单词小写，后面每个单词首字母大写 studentNameBy/studentAge;
4. 在同一个作用域中，不能重复。
总结:字母数字下划线美元$符号,不能数字开头
1.5 变量和常量：
常量: 在程序运行期，这个值应该一直保持不变
使用 final 修饰
final 数据类型 变量名
变量:通俗来说，就是和常量对应，程序运行期内是可以发生改变的，
本质来讲，变量应该是在内存中一个存储区域;
这个存储区域是有大小的，大小是由数据类型来确定的;
1.6 java中两大数据类型
基本数据类型(8种)和引用数据类型
1.7 常见的数据类型：
int :整数 4字节长度
float :单精度浮点型 4字节 精确到6位
double :双精度浮点型 精确到15位 8个字节
char : 字符 2字节
如何定义变量和常量:
数据类型 变量名 = 值; //将右侧的值 赋值给左侧的那个变量
public class Test01 {
public static void main(String[] args) {
// TODO Auto-generated method stub
//创建时直接赋值
int i=1;
//创建后再赋值
int i1;
i1=2;
//同时创建多个变量
int j,k,l;
j=1;k=2;l=3;
//同时创建多个变量,并赋值
int j1=2,k1=3,l1=4;
//如果用+链接数字格式的变量,直接做加法运算
System.out.println(i+i1);//3
//如果时字符串与变量用+连接,就叫做拼接
System.out.println("i="+i);//i=1
int a=1,b=2,c=3;
System.out.println("a="+a+",b="+b+",c="+c);//a=1,b=2,c=3
//变量的值可以改变
a=2;
System.out.println(a);//2
}
}
基本数据类型:8种, 基本数据类型是存放在栈中;
Java语言中的基本数据类型可以分为数值型、字符型、布尔型三大类，具体包
含8个类型；
每种具体类型使用一个关键字表示；
| 类型 | 长度(位) | 长度(字节) | 表示范围 |
|---|---|---|---|
| byte | 8位 | 1字节 | -128~127(-2^7 - 2^7-1) |
| short | 16位 | 2字节 | -32768~32767(-2^15 - 2^15-1) |
| int | 32位 | 4字节 | -2147483648~21447483648(-2^31 - 2^31-1) |
| long | 64位 | 8字节 | (-2^63 - 2^63-1) |
| float | 32为 | 4字节 | -3.403E38~3.403E38(-2^31 - 2^31-1) |
| double | 64位 | 8字节 | -1.798E308~1.798E308(-2^63 - 2^63-1) |
| char | 16位 | 2字节 | 表示一个字符(0 - 2^16-1) |
| boolean | 8位 | 1字节 | (true、false) |
字节类型:byte
字符类型:char
布尔类型:boolean
整型3种:short 短整型 int 整型 long 长整型 三者范围不同,由小到大
浮点型2种:float单精度 double双精度
public class Test02 {
public static void main(String[] args) {
// TODO Auto-generated method stub
//int n=1.2;Type mismatch: cannot convert from double to int
//float f=1.2;Type mismatch: cannot convert from double to float
//类型不匹配,不能从double转成float
//在java中,默认写的小数,都是double类型
//方式1:在1.2后面加上一个f
float f=1.2f;
//方式2:强制转换(显示) 高->低
//可能丢失精度(数据类型)数值
float f1=(float)1.234;
double d=f1;//这里也包含了一个类型的转换,自动转换(隐式) 低->高
double d1=1.3;
double d2=1;//这里也包含了一个类型的转换,自动转换(隐式) 低->高
}
1.7.1 ASCII码表:
public static void main(String[] args) {
// TODO Auto-generated method stub
char ch1='你';//字符 java中一个中文可以放在一个char类型的变量
char ch2=' ';//一个空格1也代表字符
char ch3='0';
char ch4='A';
char ch5='1';//这里的'1'代表的是字符1
//实际上字符是可以运算,将'1'字符转换成assii标准的十进制 49
System.out.println(ch5+ch5);//98
System.out.println(ch4+ch5-49);//65
System.out.println('A'+'0'+'z');//65+48+122
}
1.7.2 练习:
1) 实现int+char+float+double类型的求和操作;
变量定义： 数据类型 变量名 = 值;
分析: 多个数据类型累加，最终的结果是什么类型? double
public static void main(String[] args) {
// TODO Auto-generated method stub
//定义四种类型的变量
int a=1;
float f=1.25f;
char c='A';
double d=1.2334;
double sum=a+f+c+d;
System.out.println("sum:"+sum);//68.4834
//保留2位小数 f表示格式化输出浮点数
System.out.printf("%.2f",sum);//68.48
}
注意:
Java 中 print 、printf、println的区别:
printf 主要是继承了C语言的 printf 的一些特性，可以进行格式化输出;
print 就是一般的标准输出，但是不换行;
println和 print 基本没什么差别，就是最后会换行;
2）实现int+float+double类型的求和操作,但是要求int,float,double是从控制台输入进来的;
public class Test02 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
System.out.println("请输入int数据类型：");
int i = sc.nextInt();
System.out.println("请输入float数据类型：");
float f = sc.nextFloat();
System.out.println("请输入double数据类型：");
double d = sc.nextDouble();
double sum=i+f+d;
System.out.printf("%.2f",sum);
//用完记得要关闭
sc.close();
}
java控制台输入用法Scanner待会会讲到
1.8 数据类型转换
1. 自动转换(隐式):低精度赋值给高精度
2. 强制转换(显式):高精度赋值给低精度 (数据类型)变量
1. 9 有意思的代码
public class Test07_short {
public static void main(String[] args) {
short x=-32768;
// 范围-32768~32767
// --x,表示的是在原来的那个值的基础上,-1;
System.out.println(--x);//32767(-32769超过了它的最小临界值，刚好会是它最大值)
short y=32767;
System.out.println(++y);//-32768(32768超过了它的最大临界值，刚好会是它最小值)
}
1.10 堆、栈、常量池、方法区
• 数据都是存放在内存中;
• Java内存大体可以分为堆、栈、常量池、方法区;
1.11 引用类型
引用类型: 类 接口 枚举 注解 数组等;
基本数据类型存储在栈中；
引用类型存储在堆中(这句话不太严谨,引用类型要分为引用类型实例的引用和成员变量)；
• 在函数（方法）中定义的基本数据`类型变量存储在栈中；
• 引用类型实例的引用（reference）也是存储在栈中;
• 引用类型实例的成员变量，存储在堆中;
1.12 控制台输入:
Scanner
| double | nextDouble() | 将输入信息的下一个标记扫描为一个 double |
|---|---|---|
| float | nextFloat() | 将输入信息的下一个标记扫描为一个 float |
| int | nextInt() | 将输入信息的下一个标记扫描为一个 int |
Scanner 使用分隔符模式将其输入分解为标记,默认情况下该分隔符模式与空白匹配.然后可以使用不同的next方法将得到的标记.
当通过new Scanner(System.in)创建一个Scanner，控制台会一直等待输入，直到敲回车键结束，把所输入的内容传给Scanner，作为扫描对象。如果要获取输入的内容，则只需要调用Scanner的nextLine()方法即可。
//目的的是导入Scanner类所在的位置
import java.util.Scanner;
public class Test_Scanner {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数:");
int i = sc.nextInt();
System.out.println("请输入一个单精度浮点数:");
float f = sc.nextFloat();
System.out.println("请输入一个双精度浮点数:");
double d = sc.nextDouble();
double sum=i+f+d;
System.out.printf("累加的和:%.2f",sum);
//用完了记得要关闭,也可以不关,但是代码多了之后会影响运行速度
sc.close();
}
}
1.13 运算符:
赋值运算符: = int a =1; += -= … a=a+b; a+=b
算术运算符: + - * / %(取余) ++（自加） --（自减）
比较(关系) : == != > < >= <= 返回值是一个boolean类型的 true /false
逻辑运算符：与&&（短路与） 或 ||（短路或） 非！取反
位运算符（了解） &
三目运算符：表达式 ?“值1”:“值2” 如果表达式为真，得到值1，否则值2
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
System.out.println("请输入一个数:");
Scanner scanner = new Scanner(System.in);
int i = scanner.nextInt();
//对i进行一些操作
//表达式 ? “值1” : “值2”
System.out.println(i%2==0?"偶数":"奇数");
}
}
1.13.1 简单的比较问题:
System.out.println("比较2个整数:");
int a=1,b=1;
System.out.println("a==b:"+(a==b));//a==b:true
System.out.println("a!=b:"+(a!=b));//a==b:false
System.out.println("比较2个小数:");
//因为数字值1.0 ,其实本质上java代码处理的时候当成整数的
//二进制
double d=1.0d;
float f=1.0f;
System.out.println("d==f:"+(d==f));//true
//因为赋的值是小数,数据类型不一样
double d1=1.05d;
float f1=1.05f;//0.25 0.5 这样的值
System.out.println("d1==f1:"+(d1==f1));//false
System.out.println("d1>f1:"+(d1>f1));//true
1.13.2 ++和–
（单目）来变量的基础上自加 1或者自减1 : a++ --a ；
无论是在前还是在后，最终的结果一定是+1或者-1;
| 运算符 | 放在变量前 | 放在变量后 |
|---|---|---|
| ++ | ++a ; 先自加，再引用a的值 | a++ ; 先引用a的值，然后在自加 |
| – | –a ; 先自减，再引用a的值 | a-- ;先引用a的值，然后再自减 |
public class Test11 {
public static void main(String[] args) {
int n=1;
++n;//2
n++;//3
System.out.println("n="+n);//3
int i=1;
System.out.println("i="+ i++);//1 先用再加1(在输出的内容中先引用i=1的值,输出表达式之后的最终结果再加上1,此时i=2)
System.out.println("i="+ ++i);//3 先加1再用(在输出的内容中i先加上1再引用,i=2+1=3,输出表达式之后的最终结果也时3)
int a=2,b;
//b=++a;//a先自加1,再引用a的值,赋值给b
b=a++;//先引用a的值,赋值给b,a再自加1
System.out.println(a+","+b);//3,2 此处输出的是上面的最终结果,a经过先赋值引用再自加为3,需要注意的是赋值也算引用
}
}
1.13.3 关于位运算符
笔试题:
如何用比较快速的方法得到2的4次方?
16 8 4 2 1
1 0 0 0 0 //二进制可以理解为只有0和1两个数字,数字增长只能逢二进一,就像十进制中只有0~9十个数字,10就是1和0拼凑;这里只要记住2的二次方,哪个位置只要有1,将它们加起来就是十进制代表的值;例如二进制10101转换成十进制就是16+4+1=21)
1 0 0 0 0=16
2<<3 <<向左移动三位
00010 ->10000=>16 //这里将2转换成二进制状态,再将1向左移动3位再转换成十进制)
十进制的2转换为二进制10 > 位运算 10000 ->变成10进制
int n = 2;
System.out.println(2 << 3);
1.13.4 逻辑运算符
public class Test01 {
public static void main(String[] args) {
String hair="长发飘飘";
int height=170;
//比较equals()比较字符串中所包含的内容是否相同;
// == 比较两个变量本身的值，即两个对象在内存中的首地址(java中，对象的首地址是它在内存中存放的起始地址，它后面的地址是用来存放它所包含的各个属性的地址，所以内存中会用多个内存块来存放对象的各个参数，而通过这个首地址就可以找到该对象，进而可以找到该对象的各个属性)
System.out.println(hair.equals("长发飘飘") & height==170);//true
System.out.println(hair.equals("长发飘飘") && height==170);//true
//如果是&&短路运算,左侧为false,则右侧不执行 有假即假
int a=1,b=2,c=3;
System.out.println(a++ > b++ && --b < c++);//false
System.out.println("a="+a+",b="+b+",c="+c);//2 3 3
//如果是&非短路运算,左侧为false,右侧也会执行 有假即假
int a=1,b=2,c=3;
System.out.println(a++ > b++ & --b < c++);//false
System.out.println("a="+a+",b="+b+",c="+c);//2 2 4
//如果是||短路运算,左侧为true,则右侧不执行 有真即真
int a=1,b=2,c=3;
System.out.println(a++ < b++ || --b < c++);//true
System.out.println("a="+a+",b="+b+",c="+c);//2 3 3
//如果是|非短路运算,左侧为true,右侧也会执行 有真即真
int a=1,b=2,c=3;
System.out.println(a++ < b++ | --b < c++);//true
System.out.println("a="+a+",b="+b+",c="+c);//2 2 4
}
}
面试题：&&与&的区别
1.&&短路与逻辑运算符;
2.&可以作为非短路与运算，也可以作为位运算;
3.如果是&&短路与运算,只要有一个条件为false,后面的条件都不执行;
4.如果是&非短路与运算,如果有一个条件为false,后面的条件也都会执行;
1.13.5 小题目(逻辑运算符)面试和考试出现的题目非常大
String s=null;
System.out.println(s!=null && s.length()>2);
System.out.println(s!=null & s.length()>2);
输出的结果是什么?
String 是一个引用类型的变量
如果引用的目标为null,那么java中是不允许出现对象名.属性或者方法的
&& :短路与 ,如果左侧是false,则右侧则不执行,false
&:非短路与,如果左侧是false,右侧也会执行,此时会出现错误
输出结果:
public static void main(String[] args) {
// TODO Auto-generated method stub
String s=null;
System.out.println(s!=null && s.length()>2);//fasle
System.out.println(s!=null & s.length()>2);//这里非短路与,左侧为flase,右侧也会执行
}
false
Exception in thread "main" java.lang.NullPointerException
at day03.Test02.main(Test02.java:9)//一个异常,空指针异常,如果一个引用为空,但是我们又执行这个引用的方法或者属性就会报错
1.14 运算符小结:
类型分:
赋值运算符（= += -= ….）
算术运算符(+ - * / % ++ --)
逻辑运算符(&& || ! & |)
关系(比较)运算符 (> < >= <= != ==)
位运算符(<<)
按照”目” :
双目 a+b =>
单目 a++ ,a –
三目: 表达式1? 表达式2:表达式3 ;
sum+=i sum=sum+i
1.15 运算符-优先级描述
1 括号()、[]
2 正负号+、-
3 自增自减，非++、--、!
4 乘除，取余*、/、%
5 加减+、-
6 移位运算<<、>>、>>>
7 大小关系>、>=、<、<=
8 相等关系==、!=
9 按位与&
10 按位异或^
11 按位或|
12 逻辑与&&
13 逻辑或||
14 条件运算?:
15 赋值运算=、+=、-=、*=、/=、%=
16 位赋值运算&=、|=、<<=、>>=、>>>=
1.16 练习:
1. 从控制台输入3个数,并求最大值;
public class Test {
public static void main(String[] args) {
System.out.println("请输入3个数:");
Scanner scanner=new Scanner(System.in);
int a=scanner.nextInt();
int b=scanner.nextInt();
int c=scanner.nextInt();
int max=a >b?a:b;//max就是a和b的最大值
max=max>c?max:c;
System.out.println("max:"+max);
scanner.close();
}
2. 从控制台输入两个数字,将这2个数字交换后输出(不定义第三个变量)
public class Test {
public static void main(String[] args) {
System.out.println("请输入2个数:");
Scanner scanner=new Scanner(System.in);
int a=scanner.nextInt();
int b=scanner.nextInt();
System.out.println("交换之前:a="+a+",b="+b);
//方式1:定义一个中间变量
int t=a;
a=b;
b=t;
//方式2:不定义第三个变量
//将a和b相加赋值给a
a=a+b;// a=1 b=2 相加之后 a=3,b=2
b=a-b;//3-2=1
a=a-b;//3-1=2
//交换后输出
System.out.println("交换之后:a="+a+",b="+b);
//关闭
scanner.close();
}
}
1.8 总结：
1、 类结构,变量,常量(final),声明，赋值，定义，命名规则等.
2、 数据类型(8个基本类型 byte .short.int.long.float.double.char.boolean),存储在栈中
3、 引用类型:引用名存储在栈中,对象(内容)存储在堆中
4、 运算符(= ==)
5、 控制台的输入(Scanner)
103
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
