文章目录
Java基础
注释、标识符、关键字
注释
-
平时编码，在代码量较少的时候，可以看懂自己写的，但是当项目结构一旦复杂起来，我们就需要用到注释了。
-
主释并不会被执行，是给我们写代码的人看的
-
书写注释是一个非常好的习惯
-
平时写代码一定要注意规范
-
三种注释
-
public class HelloWorld { public static void main(String[] args) { //单行注释 System.out.println("helloworld"); /* 多行注释 * thanks for the kind words. * */ /** *文档注释 *@Description Hello * */ } }
关键字
- 数据类型：boolean、int、long、short、byte、float、double、char、class、interface。
- 流程控制：if、else、do、while、for、switch、case、default、break、continue、return、try、catch、finally。
- 修饰符：public、protected、private、final、void、static、strict、abstract、transient、synchronized、volatile、native。
- 动作：package、import、throw、throws、extends、implements、this、supper、instanceof、new。
- 保留字：true、false、null、goto、const。
标识符
标识符是大小写敏感的
public class Demo01 {
public static void main(String[] args) {
//所有的标识符都应该以字母(a-z或A-Z)，美元符($)、或者下划线(_)开始
String Ahello = "felks";
String hello = "felks";
String $hello = "felks";
String _hello = "felks";
//否则如下会报错
//String #hello = "felks";
//String *hello = "felks";
//String 2hello = "felks";
//首字符之后可以是字母(a-z或A-Z)，美元符($)、或者下划线(_)或 数字 的任何字符组合
String _1 = "feliks";
//#等特殊字符会报错
//String _# = "feliks";
//String _% = "feliks";
//不能使用关键字作为变量名或方法
//String case = "felks";
//String class = "feliks";
//标识符是大小写敏感的
String Man = "feliks";
String man = "feliks";
//合法标识符举例：age,$salary,_value,__1_value
//非法标识符举例：123abc,-salary,#abc
//可以使用中文命名，但不建议使用，一般也不这样使用
String 阿飞 = "feliks";
System.out.println(阿飞);
}
}
数据类型
Java是一种强类型语言
- 要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用
优点：安全性高 缺点：速度较慢
与之相对的弱类型语言
如VBScript、JavaScript等
public class Demo02 {
public static void main(String[] args) {
String a;
System.out.println(a);
}
}
Java的数据类型分为两大类
- 基本类型(primitive type)
- 引用类型(reference type)
代码中尝试，通过错误使用可加深印象
public class Demo02 {
public static void main(String[] args) {
//8大基本数据类型
//整数
//Integer 可点进去看最大最小值
//Byte
int num1 = 10; //最常用
// byte num2 = 200;//超过-128--127报错
short num3 = 30;
long num4 = 30L; //Long类型要在数字后面加个L
//小数：浮点数
float num5 = 50.1F; //float类型要在数字后面加个F
double num6 = 3.14159265;
//字符
// char name = '阿飞'; 两个字会报错
char name = '飞';
//字符串，String不是关键字，是类
String name1 = "阿飞";
//布尔值：是非
boolean flag = true;
boolean flag1 = false;
}
}
顺便一提：什么是字节？
-
**位(bit)：**是计算机内部数据储存的最小单位，11001100是一个八位二进制数
-
字节(byte)：是计算机中数据处理的基本单位，习惯上用大写B来表示
-
1B(byte,字节)：=8bit(位)
-
**字符：**是指计算机中使用的字母、数字、字和符号
-
1bit表示1位
-
1Byte表示一个字节1B=8b
-
1024B=1KB
-
1024KB=1M
-
1024M=1G
数据类型扩展及面试题分析
整数拓展:
进制 二进制0b开头
十进制
八进制0开头
十六进制0x开头
public class Demo03 {
public static void main(String[] args) {
//整数拓展: 进制 二进制0b 十进制 八进制0 十六进制0x
int i = 10;
int i2 = 010;//八进制0
int i3 = 0x10;//十六进制0x 0~9 A~F 16
System.out.println(i);
System.out.println(i2);
System.out.println(i3);
}
}
/**
输出结果为
10
8
16
*/
浮点数拓展：银行业务怎么表示？
//用BigDecimal 数学工具类 //======================================================
//float 是有限的，离散的 存在舍入误差 大约 接近但不等于
//double
//最好完全避免使用浮点数进行比较
//最好完全避免使用浮点数进行比较
//最好完全避免使用浮点数进行比较
pulic class Demo05{
public static void main(String[] args){
float f = 0.1f;//0,1
double d = 1.0/10;//0.1
System.out.println(f==d);//false
float d1 = 232323232323232f;//大数
float d2 = d1+1;
System.out.println(d1==d2);//true
}
}
字符拓展
public class Demo06{
public static void main(String[] args){
char c1 = 'a';
char c2 = '陈';
System.out.println(c1);
System.out.println((int)c1);//强制转换
//分别输出
//a
//97
System.out.println(c2);
System.out.println((int)c2);//强制转换
//分别输出
//陈
//38472
//原理
//所有的字符本质还是数字
//char类型涉及到编码问题
//Unicode 编码可以处理各种语言文字，占2个字节 0-65536 最早的Excel表最长只有2^16=65536
//Unicode表：(97 = a 65 = A....)
//U0000 UFFFF
//Unicode编码表示方式
char c3 = '\u0061';//a
//‘\u’表示转义
System.out.println(c3);
//输出a
//转义字符
//\t 制表符
//\n 换行
//...
System.out.println("hello\tworld");
System.out.println("====================");
String sa = new String("feliks");
String sb = new String("feliks");
System.out.println(sa==sb);
//false
String sc = "feliks";
String sd = "feliks";
System.out.println(sc==sd);
//true
//等到对象时 再从内存分析
}
}
布尔值扩展
public class Demo07{
public static void main(String[] args){
boolean flag = true;
if (flag==true){}
if (flag){}//二者功能相同更精简
//Less is more 代码要精简易读
}
}
类型转换
由于Java是强类型语言，所以要进行有些运算的时候，需要用到类型转换
低 ----------------------------> 高
byte,short,char-> int-> long-> float->double
运算中，不同类型的数据先转化为同一类型，然后进行运算。
- 强制转换
- 自动转换
public class Demo05 {
public static void main(String[] args) {
int i= 128;
//强制转换
byte b = (byte)i;//内存溢出
//自动转换
double d = i;
//强制转换 (类型)变量名 高-->低
//自动转换 低-->高
System.out.println(i);//128
System.out.println(b);//-128 因为byte范围-128~127,内存溢出了
System.out.println(d);//128.0
/*注意点：
1.不能对布尔值进行转换
2.不能把对象类型转换为不相干的类型
3.在把高容量转换到低容量时，不需要强制转换
4.转换时可能存在内存溢出，或者精度问题！
*
* */
System.out.println("======测试精度问题======");
System.out.println((int)23.7);//23
System.out.println((int)-45.67f);//-45
System.out.println("======char======");
char c = 'a';
int e = c+1;//char->int低到高自动转换
System.out.println(e);//98
System.out.println((char)e);//b
}
}
扩展：操作大数时的溢出问题
public class Demo06 {
public static void main(String[] args) {
//操作比较大的数的时候，注意溢出问题
//JDK7新特性：数字之间可以用下划线分割
int money = 10_0000_0000;
int year = 20;
int total = money*year;//-1474836480 计算的时候溢出了
long total2 = money*year;//默认是int，转换之前已经存在问题了，所以还是负数。
System.out.println(total);//-
long total3 = money*(long)year;
System.out.println(total3);//先把一个数转换为long,正确输出√
//这样也可以诶√
long years = 20l;
long total4 = money*years;
System.out.println(total4);
}
}
变量、常量
变量
- 变量就是可以变化的量
- Java是一种强类型语言，每个变量都必须声明其类型
- Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域
type varName [=value] [{,varName[=value]}];
//数据类型 变量名 =值
//可以使用逗号隔开来声明多个同类型变量（不建议使用）
- 注意事项
- 每个变量都有类型，类型可以是基本类型，也可以是引用类型(例如String)
- 变量名必须是合法的标志
- 变量声明是一条完整的语句，因此每一个声明都必须以分号结束
public class Demo07 {
public static void main(String[] args) {
// int a=1,b=2,c=3;//程序可读性差
//基本类型
int a = 1;
char x = 'X';
double pi =3.14;
//...
//引用类型
String name = "阿飞";
}
}
代码体验
public class Demo08 {
//类变量 static
static double salary = 2500;
//属性：变量
//实例变量：在类里面，方法外面。
//实例变量从属于对象：如果不自行初始化，这个类型的默认值 0 0.0
//布尔值：默认是false
//除了基本类型，其余的默认值都是null
String name="feliks";
int age;
//main方法
public static void main(String[] args) {
//局部变量：必须声明和初始化值
int i = 10;
System.out.println(i);
//变量类型 变量名字 = new Demo08();
Demo08 demo08 = new Demo08();
System.out.println(demo08.name);
//类变量 static
System.out.println(salary);
}
//其他方法
public void add(){
}
}
变量作用域
暂且学会static、final即可
- 类变量
- 实例变量
- 局部变量
public class Variable{
static int allClick=0; //类变量
String str = "hello"; //实例变量
public void method(){
int i; //局部变量
}
}
常量
- 常量(Constant)：初始化(initialize)后不能再改变值！也不会变动的值
- 所谓常量可以理解成为一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变
- 关键字，final
final 常量名=值
final double PI = 3.14
- 常量名一般使用大写字母
public class Demo09 {
//修饰符，不存在先后顺序
//static final换位后不影响
static final double PI = 3.14;
public static void main(String[] args) {
System.out.println(PI);
}
}
变量的命名规范
- 所有变量、方法、类名：要求见名知意
- 类成员变量：首字母小写和驼峰原则：除了第一个单词以外，后面的单词首字母大写：monthSalary
- 局部变量：首字母小写和驼峰原则
- 常量：大写字母和下划线：MAX_VALUE
- 类名：首字母大写和驼峰原则：Man,SpiderMan
- 方法名：首字母小写和驼峰原则：run()，runOver()
运算符(operator)
- Java语言支持如下运算符
- 算术运算符: +，-，，l，%，++，–***
- 赋值运算符: =
- 关系运算符:>，<，>=，<=，==，!= instanceof
- 逻辑运算符: &&，||，!
- 位运算符: &，|，^，~，>>，<<，>>>(了解!! ! )
- 条件运算符: ? ∶
- 扩展赋值运算符:+=，-=，*=，/=
二元运算符
package operator;
public class Demo01 {
public static void main(String[] args) {
//二元运算符
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);
}
}
public class Demo02 {
public static void main(String[] args) {
long a = 1234567891012L;
int b = 123;
short c = 10;
byte d = 8;
//两个或多个操作数中有一个类型为Long，那么结果类型为Long
System.out.println(a+b+c+d);//Long
//没有Long时，结果都为Int,无关有无Int
System.out.println(b+c+d);//Int
System.out.println(c+d);//Int
//有Doubele，结果为Double
System.out.println((double)c+d);//Double
}
}
关系运算符
public class Demo03 {
public static void main(String[] args) {
//关系运算符的返回结果：true,false 布尔值
//if
int a = 10;
int b = 20;
int c = 21;
//取余，模运算
System.out.println(c%a);//1 c/a -> 21/10 = 2...1
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赋值，再自增
//a++ a = a+1;
//++a a = a+1;
int c = ++a;//执行完这行代码前，先自增，再给c赋值
System.out.println(a);//5
System.out.println(b);//3
System.out.println(c);//5
//幂运算2^3
//很多幂运算，会使用一些工具类来操作
double pow = Math.pow(2, 3);
System.out.println(pow);//8
}
}
逻辑运算符
//逻辑运算符
public class Demo05 {
public static void main(String[] args) {
//与(and) 或(or) 非(取反)
boolean a = true;
boolean b = false;
//逻辑与运算：同真为真，一假为假
System.out.println("a && b:"+(a&&b));//false
//逻辑或运算：一真为真，同假为假
System.out.println("a || b:"+(a||b));//true
//取反
System.out.println(("!(a && b):"+!(a&&b)));//true
//短路运算
int c = 5;
boolean d = (c<4)&&(c++<4);
//验证：若&&前的为假，则不执行&&后的
System.out.println(d);//false
System.out.println(c);
//输出c=5，说明(c++<4)未被执行，若执行，c应该为6
}
}
位运算(面试题)
//位运算
public class Demo06 {
public static void main(String[] args) {
/*
* A = 0011 1100
* B = 0000 1101
*----------------
* A&B 0000 1100 同1为1
* A|B 0011 1101 同0位0
* A^B 0011 0001 不同为1，相同为0
* ~B 1111 0010 取反
*
* 面试题
*
* 2*8 = 16怎么算最快？ 2*2*2*2
* 效率极高
* <<左移 *2
* >>右移 /2
* 0000 0000 0
* 0000 0001 1
* 0000 0010 2
* 0000 0100 4
* 0000 1000 8
* */
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
System.out.println(a);//30
//字符串连接符 在'+'两侧，只要有一方有String类型，会将另外的操作数都转换成String再进行连接
System.out.println(a+b);//30
System.out.println(""+a+b);//1020
/*
* 面试题:二者结果有何不同
* System.out.println(""+a+b); 1020
* System.out.println(a+b+""); 30
* */
}
}
三元运算符
//三元运算符
public class Demo09 {
public static void main(String[] args) {
//x ? y : z
//如果x==true,则结果为y,否则结果为z
int score = 80;
String s = score < 60 ? "不及格":"及格"; //必须掌握
System.out.println(s);
//输出及格
}
}
包机制、JavaDoc
包机制
- 为了更好的组织类，Java提供了包机制，用于区别类名的命名空间
- 包语句的语法格式为：
package pkg1[.pkg2[,pkg3...]];
- 一般利用公司域名倒置作为包名；net.cqwu
- 为了能够使用某一包的成员，我们需要在Java程序中明确导入该包。使用"import"语句可完成此功能
import package1[.package2...],(classname|*);
JavaDoc
- javadoc命令是用来生成自己API文档的
- 参数信息
- @author 作者名
- @version 版本号
- @since 知名需要最早使用的jdk版本
- @param 参数名
- @return 返回值情况
- @throws 异常抛出情况
package net.cqwu.base;
/**类注释
*
* @author feliks
* @version 1.0
* @since 1.8
*/
public class Doc {
String name;
/**方法注释
*
* @param name
* @return
* @throws Exception
*/
public String test(String name)throws Exception{
return name;
}
//通过命令行 javadoc 参数 Java文件
//学会查找使用IDEA生产JavaDoc文档！ 面向百度编程
//基础部分的这些知识，会经常用
}
29万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
