Java基础知识课堂随记
一、注释
注释分三种：
1.单行注释：//双斜杠开始
2.多行注释：/*斜杠+星号起始，星号+斜杠结束*/
3.文档注释：/**斜杠双星号起始，星号+斜杠结束*/
二、标识符
- 关键字：Java关键字是对Java编译器有特殊含义的字符串，是编译器和程序员的一个约定，程序员利用关键字来告诉编译器其声明的变量类型、类、方法特性等信息。Java语言共定义了如下所示的关键字。
- 标识符：Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。
- 标识符注意点：
- 所有的标识符都应该以字母（A-Z 或者 a-z），美元符（$），或者下划线（_）作为开始。
- 首字母之后可以是字母、美元符、下划线或数字的任何字符组合。
- 不能使用关键字作为变量名或方法名。
- 标识符是大小写敏感的。
- 注意数字不能开头。
三、数据类型
- 强类型语言：
Java是强类型语言，要求变量的使用要严格符合规定，所有变量都必须先定义后使用。 - 弱类型语言：如VB、JS
- Java的数据类型分为两大类
- 基本类型
- 引用类型
public class HelloWorld {
public static void main(String[] args) {
//八大基本数据类型
int num1 = 10;//最常用
byte num2 = 20;
short num3 = 30;
long num4 = 30L;//Long类型要在数字后面加个L
//小数：浮点数
float num5 = 50.1F;//float类型要在数字后面加个F
double num6 = 3.1415926;
//字符
char name = 'A';
//字符串，String不是关键字，它是一个类
String name1 = "Wang";
//布尔值：代表 是非
boolean flag = true;
}
}
补充：
- 整数类型的进制：
- 二进制：0b
- 十进制：
- 八进制：0
- 十六进制：0x
public class HelloWorld{
public static void main(String[] args){
//整数扩展： 进制 二进制0b 十进制 八进制0 十六进制0x
int i = 10;
int i2 = 010; //八进制0
int i3 = 0x10; //十六进制0x 0-9 A-F
System.out.println(i); //输出10
System.out.println(i2); //输出8
System.out.println(i3); //输出16
}
}
- 浮点类型的比较：
浮点数字存在舍入误差，最好避免使用浮点数进行比较
public class HelloWorld{
public static void main(String[] args){
//浮点数扩展
//float 有限 离散 舍入误差 大约 接近但不等于
//double
//最好完全避免使用浮点数进行比较
//补充：BigDecimal 数学工具类
float f = 0.1f;
double d = 1.0/10;
System.out.println(f);
System.out.println(d);
System.out.println(f==d); //输出false
float d1 = 2311232312312312312312312f;
float d2 = d1 + 1;
System.out.println(d1==d2); //输出true
}
}
- 字符：
所有字符本质上还是数字
public class HelloWorld{
public static void main(String[] args){
//字符扩展
char c1 = 'a';
char c2 = '中';
System.out.println(c1); //输出a
System.out.println((int)c1); //强制转换类型，输出97
System.out.println(c2); //输出'中'
System.out.println((int)c2); //强制转换类型，输出20013
//所有的字符本质还是数字
//编码 Unicode编码 表：(97 = a 65 = A) 占2字节 最多表示65536个字符 最早的Excel表格 最长 2^16 = 65536
//U0000 UFFFF
char c3 = '\u0061';//Unicode编码表示a
System.out.println(c3);//输出a
}
}
- 转义字符：
- \t 制表符，相当于一个Tab
- \n 换行，相当于一个回车
public class HelloWorld{
public static void main(String[] args){
//转义字符
// \t 制表符
// \n 换行
// ......
System.out.println("Hello\nWorld");
}
}
- 补充：变量，实际上代表一个对象的内存空间，不同的变量名指向的可以是相同的对象。
public class HelloWorld{
public static void main(String[] args){
String sa = new String("hello,world");
String sb = new String("hello,world");
System.out.println(sa==sb); //输出false
String sc = "hello,world";
String sd = "hello,world";
System.out.println(sc==sd); //输出true
//对象 要从内存分析问题 比较的是地址？
}
}
四、数据类型的转换
- Java是强类型语言，所以要进行有些运算的时候的，需要用到类型转换。
- 类型转换优先级：
- 在运算中，不同类型的数据先转化为同一类型，然后进行运算。
- 类型转换分为：
- 强制类型转换
- 自动类型转换
public class HelloWorld{
public static void main(String[] args){
//强制转换： (类型)变量名 高-->低
//自动转换 低-->高
int i = 128;
byte b = (byte)i; //强制转换，内存溢出 byte 最高127
double c = i; //自动转换
System.out.println(i); //输出128
System.out.println(b); //因为内存溢出，输出-1
/*
注意点：
1. 不能对布尔值进行转换
2. 不能把对象类型转换为不相干的类型
3. 在把高容量转换到低容量的时候，强制转换
4. 转换的时候可能存在内存溢出，或者精度问题！
*/
System.out.println("=============================");
System.out.println((int)23.7); //小数点舍弃，输出23
System.out.println((int)-45.89f); //小数点舍弃，输出-45
System.out.println("=============================");
char h = 'a';
int d = h+1;
System.out.println(d); //自动类型转换，输出98
System.out.println((char)d); //强制类型转换，输出b
}
}
- 注意点：内存溢出问题：
当操作比较大的数的时候，注意溢出问题，可在计算时先进行强制类型转换
public class HelloWorld{
public static void main(String[] args){
/*=======================================*/
//操作比较大的数的时候，注意溢出问题
//JDK7新特性,数字之间可以用下划线分割
int money = 10_0000_0000;
int years = 20;
int total = money*years; //结果是-1474836480，计算的时候溢出了
long total2 = money*years; //结果是-1474836480默认是int，转换之前已经出现问题了
long total3 = money*(long)years;//结果是20000000000，先把一个数转换为long
System.out.println(money); //输出1000000000
System.out.println(total); //输出-1474836480 有溢出
System.out.println(total2); //输出-1474836480 有溢出
System.out.println(total3); //输出20000000000 结果正确
}
}
五、变量
- 什么是变量？
- 变量就是可以变化的量，变量相当于一个空间，变量名标记这个空间的位置。
- Java是一种强类型语言，每个变量都必须声明其类型。
- Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型，和作用域。
- 变量的定义：
//变量的定义
type varName [=value] [{,varName[=valus]}]; //格式
int Name = 123；
//数据类型 变量名 = 值；可以使用逗号隔开来声明多个同类型变量。
- 注意事项
- 每个变量都有类型，类型可以是基本类型，也可以是引用类型。
- 变量名必须是合法的标识符。
- 变量声明是一条完整的语句，因此每一个声明都必须以分号结束。
- 变量的作用域：
Java语言支持的变量类型有：- 类变量：独立于方法之外的变量，用static修饰
- 实例变量：独立于方法之外的变量，不过没有static修饰
- 局部变量：类的方法中的变量
public class Variable{
static int allClicks=0; // 类变量
String str="hello,world"; // 实例变量
public void method(){
int i =0; // 局部变量
}
}
- 类变量(静态变量)：
public class bianliang {
//类变量 static
static double salary = 2500;
//main方法
public static void main(String[] args) {
//类变量 static
System.out.println(salary);
}
}
- 实例变量：
public class Employee {
//实例变量;从属于对象;如果不自行初始化，所有数值类型默认值 0 0.0
//布尔值：默认是false
//除了基本类型，其余的默认值都是null;
String name;
int age;
public static void main(String[] args) {
//变量类型 变量名字 = new Employee();
Employee Name = new Employee();
System.out.println(Name.age);
System.out.println(Name.name);
}
}
- 局部变量:
public class bianliang {
//main方法
public static void main(String[] args) {
//局部变量：必须声明和初始化值
int i = 10;
System.out.println(i);
}
}
六、常量
- 常量：初始化后不能在改变值！不会变动的值。
- 所为变量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。
//final 变量名 = 值;
final double PI = 3.14;
- 常量名一般使用大写字符。
public class changliang {
//修饰符，不存在先后顺序
static final double PI = 3.14;
final static double P = 3.14;
public static void main(String[] args) {
System.out.println(PI);
System.out.println(P);
}
}
变量的命名规范
- 所有变量、方法、类名：见名知意
- 类成员变量：首字母小写和驼峰原则：monthSalary 除了第一个单词外，后面的单词首字母大写 lastname lastName
- 局部变量：首字母小写和驼峰原则
- 常量：大写字母和下划线：MAX_VALUE
- 类名：首字母大写和驼峰原则：Man,GoodMan
- 方法名：首字母小写和驼峰原则：run(), runRun()
七、运算符
- Java语言支持如下运算符：优先级()
- 算术运算符：+,-,*,/,%,++,–
- 赋值运算符：=
- 关系运算符：>,<,>=,<=,==,!=instanceof
- 逻辑运算符：&&,||,!
- 位运算符：&,|,^,~,>>,<<,>>>(了解!!!)
- 条件运算符：?:
- 扩展赋值运算符：+=,-=,*=,/=
- 算术运算符：
public class Demo01 {
public static void main(String[] args){
// 二元运算符
//Ctrl + D :复制当前行到下一行
int a = 10;
int b = 20;
int c = 25;
int d = 25;
System.out.println(a+b);
System.out.println(a-b);
System.out.println(a*b);
System.out.println(a/(double)b); // int类型不算小数点
}
}
- 计算中各种类型之间会自动转换：
public class Demo02 {
public static void main(String[] args) {
long a = 123123123123123L;
int b = 123;
short c = 10;
byte d = 8;
System.out.println(a+b+c+d); //Long 按照类型优先级自动转换类型
System.out.println(b+c+d); //Int
System.out.println(c+d); //Int
}
}
- 关系运算符：
public class Demo03 {
public static void main(String[] args) {
//关系运算符返回的结果：正确，错误 布尔值
//常用于 if 语句
int a = 10;
int b = 20;
int c = 21;
System.out.println(c%a); //取余||模运算
System.out.println(a>b); //输出false
System.out.println(a<b); //输出true
System.out.println(a==b); //输出false
System.out.println(a!=b); //输出true
}
}
- 自增（自减）运算符：++、- -
public class Demo04 {
public static void main(String[] args) {
//++ -- 自增，自减 一元运算符
int a = 3;
int b = a++; //执行完这行代码后，先给b赋值，再自增
//b = a
//a = a + 1;
System.out.println(a); //输出4
System.out.println(b); //输出3
int c = ++a;//执行完这行代码前，先自增，再给b赋值
//a = a + 1
//c = a
System.out.println(a); //输出5
System.out.println(c); //输出5
//幂运算 2^3 2*2*2 = 8 很多运算，我们会使用一些工具类来操作！
double pow = Math.pow(2,3);
System.out.println(pow);
}
}
- 逻辑运算符与短路运算：
public class Demo05 {
public static void main(String[] args) {
//逻辑运算符
//与(and) 或(or) 非(取反)
boolean a = true;
boolean b = false;
System.out.println("a && b: "+(a&&b)); //逻辑与运算：两个变量都为真，结果才为true
System.out.println("a && b:"+(a||b)); //逻辑或运算：两个变量有一个为真，则结果才为true
System.out.println("! (a && b):"+!(a&&b)); //如果是真，则变为假，如果是假则变为真
//短路运算
int c = 5;
boolean d = (c<4)&&(c++<4); //第一个条件是false后，第二个条件中的语句将不被执行。
System.out.println(d); //输出false
System.out.println(c); //输出5，没有执行c++
}
}
- 位运算:位运算效率极高
public class Demo06 {
public static void main(String[] args) {
//位运算
/*
A = 0011 1100
B = 0000 1101
----------------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~B = 1111 0010
问：2*8怎么算最快？
2*8 = 16 2*2*2*2
位运算效率极高！！！
<< *2
>> /2
0000 0000 0
0000 0001 1
0000 0010 2
0000 0011 3
0000 0100 4
0000 1000 8
0001 0000 16
*/
System.out.println(2<<3);
}
}
- 扩展运算符：
public class Demo07 {
public static void main(String[] args) {
int a = 10;
int b = 20;
//扩展运算符
a+=b;//a = a+b
a-=b;//a = a-b
System.out.println(a);
//字符串连接符 + ,String
// + 两端出现String（字符串）类型，会拼接两边的值
System.out.println(a+b);
System.out.println(""+a+b);//先遇到字符串拼接,输出1020
System.out.println(a+b+"");//先加后拼,输出a+b的值30
}
}
- 条件运算符（三元运算符）：
//三元运算符
public class Demo08 {
public static void main(String[] args) {
// x ？ y : z
//如果x==true,则结果为y，否则结果为z
int score = 80;
String type = score <60 ?"不及格":"及格"; //必须会
//if语句
System.out.println(type); //输出'及格'
}
}
八、运算符的优先级与结合性
public class Demo07 {
public static void main(String[] args) {
int a = 1;
int b = 1;
//问a+++++b = ?
System.out.printnl(a+++++b); //(a++)+(++b)
}
}
九、包机制：包的本质就是文件夹
- 为了更好地组织类，Java提供了包机制，用于区别类名的命名空间。
- 包语句的语法格式为：
package pkg1[. pkg2[. pkg3...]];
- 一般利用公司域名倒置为包名；
- 为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用“import”语句可完成此功能
//用 import 导入一个包
import package1[.package[.package2...].(classname|*)];
- 在代码中用 Ctrl + 鼠标点击 可快速找到包的位置
- 补：Alt + 回车 提示错误信息
十、JavaDoc生成文档
-
JavaDoc命令是用来生成自己API文档的
-
参数信息
- @author
- @version版本号
- @since指明需要最早使用的JDK版本
- @param参数名
- @return返回值情况
- @throws异常抛出情况
-
通过命令行生成API文档
- 输入自己的文档注释：
package com.wang.base;
/**
* @author Wang
* @version 1.0
* @since 1.8
*/
public class Doc {
String name;
/**
*
* @param name
* @return
*/
public String test(String name){
return name;
}
}
- 选择在文件中打开Doc文件：
- 文件下打开cmd：
- 控制台输入：javadoc 参数 .java文件 。参数是字符集，防止中文字符出现乱码。
- 生成成功后查看文件：
438
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
