java基础知识

最新推荐文章于 2023-07-18 15:45:00 发布

清风挽心ii

最新推荐文章于 2023-07-18 15:45:00 发布

阅读量194

点赞数 1

分类专栏：学习总结文章标签： java

本文链接：https://blog.csdn.net/Liuxin2448/article/details/112071212

版权

学习总结专栏收录该内容

69 篇文章 0 订阅

订阅专栏

Java中注释

一般要求编写程序必须有合理的注释说明，注释一般建议控制在20%-30%代码量上。但是具体实践中一
般不会写这么多的注释，但是不写注释是不合理的

//                 单行  
/*        */       多行     
/**       */       文档

IDE工具的安装

如果使用文本编辑工具编写代码，问题在于没有任何提示，编码效率低；而且不停的需要进行切换【编辑发现问题–修改源代码】。所以需要使用IDE工具（集成开发环境），在工具中可以直接编写代码，编译源程序并执行
Eclipse 是一个开放源代码的、基于Java的可扩展开发平台。该软件是IBM使用java开发出来的并开源的。就其本身而言，它只是一个框架和一组服务，用于通过插件组件构建开发环境。幸运的是，Eclipse附带了一个标准的插件集，包括Java开发工具（Java Development Kit，JDK）。官方下载网站 eclipse.org

常用快捷键

Alt+/ 内容提示
Ctrl+Shift+F 格式化
Ctrl+shift+O 导包语句，该快捷键一次性可以导入多个包
Ctrl+1 快速修复错误，但是该快捷键只能修复小错误

语法基础

Java语言的源程序代码由一个或多个编译单元组成，每个编译单元可包含三个要素：
1、一个包声明（可选）。 package *******.*****; 命名空间
2、任意数量引入语句。 import java.util. *****;
3、类的声明和接口声明 public class A{}
一个文件中可以定义多个class，但是最多只能由一个public class，因为文件名称必须和public class类
名称一致（大小写在内）；当然在一个文件中的class名称不能重复【实际上在一个包中的类名称不能重复】，如果文件中没有public class，则文件名称没有约束

Java标识符

标识符可从一个字母(Unicode编码字符集)、下划线_或美元符号$开始，随后也可跟数字、字母、下划线或美元符号。
标识符是区分大小写，没有长度限制，可以为标识符取任意长度的名字
编码规范

类名首字母大写，大写字母分词建议名词
方法名称首字母小写，大写字母分词
变量名称首字母小写，大写字母分词
包名称全小写，使用域名反转的方式定义

变量

变量是Java程序中的基本存储单元，它的定义包括变量名、变量类型和作用域几个部分

Java属于强类型编程语言，变量类型一旦声明，则不能进行修改
数据类型可以决定变量所需要的存储空间大小和对应的处理逻辑
作用域是指变量生效的范围，从定义的位置开始，到所在的{}结束为止

JAVA是强类型语言

在Java语言数据类型可以分为两大类：基本类型（原生类型primitive type）和引用类型（复合类型referance type）
4类整数： byte 1B short 2B int 4B long 8B 默认为int 特殊后缀L/l
浮点数： float 4B double 8B 默认double 特殊后缀 f/F D/d
字符：单引号 2B unicode[java默认0-65535]
布尔： true、false
引用类型：复杂类型
class/interface 数组 null
注意：null属于引用类型，所以int k=null;语法错误

复合数据类型

复合数据类型包括：class类、interface接口、数组。
null 索引在运行时并没有对应的类型，但它可以被转换为任何类型（不能是简单类型）。
索引类型的默认值就是null

包装类

所谓包装类，就是可以直接将简单类型的变量表示为一个类，在执行变量类型的相互转换时会大量使用
这些包装类。 Java共有8个包装类，分别是Boolean、Character、Byte、Short、Integer、Long、Float和 Double，从字面上就可以看出它们分别对应于 boolean、char、byte、short、int、long、float和double。

类型包装类的作用

各种构造函数，如从字符串来构造整数
一个对应类型的数据范围：最大值、最小值
完成不同数据类型间转换的方法
需要对象的地方：如Vector, HashTable,Session等
Java提供基本类型是为了提高效率，而提供包装类是为了将基本来行看作对象，每个包装类对象封装了一个基本值。

抽象类java.lang.Number

java.lang.Number是所有表示数字类的父类，可以根据数字类型的不同对抽象该类进行扩展，它实现序列化接口。主要定义了方法byteValue():byte、 shortValue():short、 intValue():int、longValue():long、 floatValue():float和 doubleValue():double。

1  Double dd=new Double(1.23);//通过new运算符创建对象dd
2  System.out.println(dd.intValue());

具体类java.lang.Boolean

1、构造函数有Boolean(boolean)和Boolean(String)。当字串是”true”的时候则创建boolean值为true的对象，否则创建boolean值为false的对象

1  ublic class Test01 {
2  public static void main(String[] args) {
3  Boolean b1 = true;// false 自动装箱操作
4  boolean b2 = b1;// 自动拆箱操作
5   //使用构造器创建Boolean类型对象
6   Boolean b3=new Boolean(false);
7   Boolean b4=new Boolean("true");//""是字符串类型
8   // Boolean b5=new Boolean(123); 语法错误，只能是boolean类型
9   /*
   * 参数为String字符串类型的实现原理为：
   * ((s != null) && s.equalsIgnoreCase("true"))
   */
13   Boolean b6=new Boolean("abcd");
14  System.out.println(b6);
15
16  }
17  }

3.booleanValue():boolean
4.Boolean.valueOf(boolean) / (String)：Boolean

//将字符串类型的数据转换为boolean类型
1  Boolean b1=Boolean.valueOf("true");
2  boolean b2=Boolean.valueOf("false");  //自动拆箱

针对字符串和boolean类型的转换一般不使用这么繁琐的方法

1  String str="false";
2  Boolean bb="true".equals(str); //使用字符串比较的方法equals，这个方法可以进行字符串内容的比较，如果内容相等返回为true，否则false
3  System.out.println(bb);

具体类java.lang.Character

1.取值范围为Character.MIN_VALUE（0）到Character.MAX_VALUE（65535）
2、Character.isUpperCase(char)判断字符是否为大写 / isLowerCase(char)是否为小写：boolean
Character.toUpperCase(char)将字符转换为大写 / toLowerCase(char)将字符转换为小写：cha

1  Character c1='a';
2  //如果中文则返回都是false
3  System.out.println(Character.isUpperCase(c1)+"---"+Character.isLowerCase(c1));
4  char c2=Character.toUpperCase(c1);//小写转大写,实际上返回值为char类型，但是可以直接赋值给Character类型，因为自动装箱操作
6  Character c3=Character.toLowerCase(c1);//转换为小写
7  System.out.println(c2+"==="+c3);

Character.isDigit(char) / isLetter(char) / isLetterOrDigit(‘5’)：boolean

1  //判断是否为数字
2  System.out.println(Character.isDigit(c1));//'0'<=c1 && c1<='9'
3  //判断是否为Unicode字母
4  System.out.println(Character.isLetter(c1));
5  //判断数字或者字母
6  System.out.println(Character.isLetterOrDigit(c1));

具体开发中进行字母、数字之类的判定一般使用正则式进行，比上面的方法简单直接，一般不使用Character中提供的方法

1  String str = "123";
2  Pattern p = Pattern.compile("\\d{3}");
3  Matcher m = p.matcher(str);
4  boolean bb=m.matches();
5  System.out.println(bb);

具体类java.lang.Integer(Byte、Short、Long)

1、取值范围为Integer.MIN_VALUE到Integer.MAX_VALUE。
2、Integer.toString(int数据，int进制)：String将数据转换为int进制的字串。Integer.toHexString(int)是16进制；Integer.toOctalString(int)是8进制；Integer.toBinaryString(int)是2进制的。
3、Integer.parseInt(String，int进制)：int将字串按照int进制转换为10进制的整数Integer.parseInt(“-FF”,16)=-255
4、Integer.valueOf((String，int进制)：Integer将字串按照int进制转换为10进制的整数对象。Integer.parseInt(“-FF”,16)=new Integer(-255)

1  //需要掌握的是10进制数的字符串和数值之间的转换方法
2  String s1="123";
3  int kk=Integer.valueOf(s1);   //如果s1中的数据不是数值则会出现异常报错,中断程序的运行
4  int k2=Integer.parseInt(s1);
5  System.out.println(kk+"---"+k2);
6  int k3=123;
7  String s2=""+k3;
8  System.out.println(s2);

valueOf和parseInt的区别

public static Integer valueOf(String s) throws NumberFormatException 返回值得类型为包装类，底层实现其实就是parseInt

1   public static Integer valueOf(String s) throwsNumberFormatException {
2   return Integer.valueOf(parseInt(s, 10));
3   }

public static int parseInt(String s) throws NumberFormatException 返回值类型为原生类型

具体类java.lang.Double（Float）

1.取值范围为Double.MIN_VALUE到Double.MAX_VALUE。另外有public static final常数
2.POSITIVE_INFINITY正无穷大（1/0）、NEGATIVE_INFINITY负无穷大（-1/0）和NaN不是数（0/0，其中NaN!=NaN）
3.Double.valueOf(String):Double和Double.parseDouble(String):double

1  int kk=0;
2  System.out.println(10/kk);//会出现一个异常java.lang.ArithmeticException
3  //这是一个bug，应该编程严谨以处理这种问题
4  if(kk==0)
5     System.out.println("不允许除数为0");
6  else
7      System.out.println(10/kk);

数值与字串的转换

数值转换为字串有3种方法： String s=String.valueOf(i)=Integer.toString(i)=””+i;

字串与数值的转换

字串转为数值型有2种方法： int i=Integer.valueOf(s).intValue(); int i=Integer.parseInt(s) / (s,int进制)

int和Integer的区别

int是常说的整形数字，是Java的8个原始数据类型Primitive Types（boolean、byte 、short、char、int、float、double、long）之一。Java语言虽然号称一切都是对象，但原始数据类型是例外。
Integer是int对应的包装类，它有一个int类型的字段存储数据，并且提供了基本操作，比如数学运算、int和字符串之间转换等。在Java 5中，引入了自动装箱和自动拆箱功能boxing/unboxing，Java可以根据上下文自动进行转换，极大地简化了相关编程。
基于大部分数据操作都是集中在有限的、较小的数值范围，在JDK1.5中新增了静态工厂方法valueOf，其背后实现是将int值为-128到127之间的Integer对象进行缓存，在调用时候直接从缓存中获取，进而提升构建对象的性能，也就是说使用该方法后，如果两个对象的int值相同且落在缓存值范围内，那么这个两个对象就是同一个对象；当值较小且频繁使用时，推荐优先使用整型池方法（时间与空间性能俱佳）。
如果有线程安全的计算需要，建议考虑使用类型AtomicIntegerAtomicLong 这样的线程安全类。部分比较宽的基本数据类型，比如 float、double，甚至不能保证更新操作的原子性，可能出现程序读取到只更新了一半数据位的数值。

常量

常量就是指在程序执行期间其值不能发生变化的数据，常量是固定的。如整型常量123，实型常量1.23，字符常量’A’，布尔常量true等
Java中的常量用final来实现，例如final double PI=3.14;注意声明常量的时候可以不赋值，而在构造器结构中赋初值，但是若在声明时同时进行了赋值，则不可以在初始化结构中赋值了。

final boolean out=true;
// out=false;语法报错的原因是out是常量，一旦赋值则不允许在运行期间进行修改
if(out)
 System.out.println("我的第一次输出");
System.out.println("其它的输出");
if(out)
 System.out.println("我的第二次输出");

表达式

表达式就是运算符、操作数以及方法调用的序列，用来说明某个计算过程并返回计算结果
按照运算符功能来分，基本的运算符分包括算术运算符、关系运算符、位运算符、条件运算符等

算术运算符 +、-、*、/、%、++、–
关系运算符 >、<、>=、<=、==、!=
逻辑运算符 &&、 ||、 !。注意：逻辑计算支持短路操作
位运算符 &、|、^、~、<< 、 >>、>>>。注意：为运算符不支持短路操作
赋值运算符 =，+=，-=，*=，/=
三目条件运算符（？：）规则是完全一致的，使用的形式是： x ? y：z;

算术运算符

+、-、*、/、%、++、–
整除：参与运算的双方都是整数 10/3=3而不是3.33333
10./3=3.333…这里由于10.是浮点数，则3会自动转换为大类型并参与计算，所以最终是 10.0/3.0的计算
结果

int kk=3;
int res=(kk/2); //没有语法错误，因为除数和被除数都是整数，所以计算结果为整数
System.out.println(res);
//如果需要计算小数部分，则除数或者被除数之一必须为非整数
3./2=1.5
double res=(1.*kk/2);  //因为1.是double类型的浮点数，所以计算结果一定是浮点数

计算次序为先乘除后加减，如果优先级一致，则自动从左向右进行计算 10+2*5=20
%求余（取模） 10%3=1实际就是10除以3求余数

//假设总行数为10行，每页3行，如何计算需要多少页进行显示
int rowsNum = 12;// 总行数
int rowsPerPage = 3;// 每页行数
int pageNum = rowsNum / rowsPerPage;// 总页码数
System.out.println(pageNum);// 由于整除的问题，所以计算结果为3，这样就会有数据丢失
if(rowsNum%rowsPerPage!=0)
 pageNum=pageNum+1;
System.out.println("最终结果为："+pageNum);

注意：求余计算可以用于浮点数。浮点数没有整除的概念，只能针对计算结果进行强制类型转换(窄化操
作)

double dd=-12.3; //求余计算中符号不参与计算，所以计算结果为-2.4
System.out.println(dd%3.3); //执行结果为2.4000000000000012

++和–是单目运算符
i++等价于i=i+1
i–等价于i=i-1

double k = 100;
k--;// k=k-1;
System.out.println(k);

i++是先取值后计算，++i是先计算后取值

int k = 100;
 System.out.println(k++);//100 先获取k的当前值，然后再进行加1计算
 System.out.println(k);//101



int k = 100;
 System.out.println(++k);//101 先加1然后再取值
 System.out.println(k);//101
 int k = 100;



int i = 50;
int res = k+++i;  //实际是按照k++ +i进行计算
System.out.println(res);  //150
System.out.println(k + "---" + i); //101 50

比较运算符

>、<、>=、<=、==、!=

用于判断两个数据之间的大小关系，计算结果为boolean,如果成立返回为
true，否则为false

boolean bb = 1 > 2;
 System.out.println(bb);
 System.out.println(1 <= 2);
 //=是赋值计算 ==是等值判定
 int kk;
 System.out.println(kk=3);
 System.out.println(kk==3);

==和=的区别

k = 100;这是赋值运算符，意思是将=右边的计算结果储存在=左边的变量中
k = = 100这是比较计算，意思是判断k是否值为100；如果是则返回true，否则false
!=意思是判断是否不等于，表示如果相等时返回false，否则返回true
由于浮点数无法精确存放，所以判断k==1.0这个写法是错误的
正确写法： a-b的绝对值小于1e-6

Java提供了一个工具类Math

Math中包含一些常见的数学计算的实现，例如三角函数、反三角函数等，
abs()的方法实现求绝对值
Math.abs(d1-1)<1e-6 判断浮点类型的变量d1的值是否为1
double d1 = 0.999999999;
double d2 = 1;

 //一般不建议这种写法，因为浮点数无法精确存放
System.out.println(d1==d2);
double res=Math.abs(d2-d1); //Math数学库中提供的abs方法用于获取绝对值
System.out.println(res);
if(res<1e-6)
 System.out.println("d1和d2相等");
else
 System.out.println("d1和d2不相等");

floor(double):double 从小到大逼近参数最大整数
ceil(double):double从大到小逼近参数最小整数
round(double):double 四舍五入，计算时和符号无关
pow(double a, double b):double 计算a的b次方
sqrt(double a):double 针对a进行开根号计算

逻辑运算符

&&与、 ||或、 !非
表达多个条件之间的关系。例如年龄大于等于18并且年龄小于65

 age>=18 && age<65

age>1 || age<10  //逻辑错误，因为任意值都满足条件
age>1 && age<10 //正确

计算规则：

&& 同真则真，其余为假
|| 同假则假，其余为真
！非真则假，非假则真
注意：逻辑计算支持短路操作

int a = 2;
 int b = 3;
 boolean bb = a > 1 && b++ < 4;
 System.out.println(bb);//true
 System.out.println(a + ":" + b);   //2:4

int a = -2;
int b = 3;
//因为++a>1值为false,所以b++<4并没有执行，这就是短路操作
boolean bb = ++a > 1 && b++ < 4;
System.out.println(bb);//false
System.out.println(a + ":" + b);//-1:3

&&:与运算，含义是两个条件必须同时成立，可以翻译为并且年龄大于等于18并且年龄小于65: age>=18 && age<65
||：或运算，含义是两个条件中成立一个即可，可以翻译为或者
年龄小于18岁或者年龄不小于65 : age<18 || age>=65
算法规则：同假则假，否则为真
!：非运算，含义是不是，用于对某个条件进行否定
年龄不小于18
写法1：age >=18
写法2： !（age<18）
算法规则：非真则假，非假则真

短路运算

例如A && B:如果条件A为false,则不会执行B，因为根据运算规则结果一定是false，和B的值没有关系
A||B：如果条件A为true，则不会执行B，因为格局运算规则结果一定是true，和B的值没有关系
考核中主要配置++/–进行测试

位运算符

&按位与、|按位或、^按位异或、~按位取反、<<左移位、 >>右移位，空位置补符号位上的值、>>>无
符号右移位，空位置补0

int a = -2;
 int b = 3;
 //因为++a>1值为false,所以b++<4并没有执行，这就是短路操作
 boolean bb = ++a > 1 & b++ < 4;
 System.out.println(bb);//false
 System.out.println(a + ":" + b);//-1:4

7&3=3
7|3=7
7^3=4
~3=-4

赋值运算符

=，+=，-=，*=，/=
int k=100; 含义是将100赋值存储在k对应的存储单元中
k=k+3可以简写为k+=3
-= */ /=类似

int a=1;
int b=2;
short c1=1+2;  //语法不报错，因为编译器可以判定结果不越界
short c2=(short)a+(short)b;  //计算结果为int，所以这样会报错
short c3=(short)(a+b);//语法正确



short k=3;
k=k+3;  //出现了一个语法错误，因为k+3这里的3系统识别为int类型，所以计算时所有数据自动转
换为int类型，必然计算结果也是int类型，将int类型的数据赋值给short类型变量----错误
System.out.println(k);



short k=3;
k+=3;  //没有语法错误，因为+=这种符号中包含了自动类型转换

三目条件运算符
规则是完全一致的，使用的形式是： x ? y：z;
计算规则

x是一个条件表达式
如果x计算结果为true，则返回y表达式的结算结果
否则返回z表达式的计算结果

int k=-10;
int b=k>6?5:3;
System.out.println(b);

int a=5;
int b=3;
int res=++a>b--?a+++3:b---4;  
System.out.println(res);//9
System.out.println(a+":"+b);//7:2

##其他运算符
对象运算符instanceof用来判断一个对象是否是某一个类或者其子类的实例。如果对象是该类或者其子
类的实例，返回ture；否则返回false

Object k1 = 123;
System.out.println(k1 instanceof Integer);  //true
System.out.println(k1 instanceof Double);   //false

点.运算符用于访问对象实例或者类的类成员函数

System.out.println(Integer.MAX_VALUE);
int k1=12,k2=23;
System.out.println(Integer.max(k1, k2));

new运算符用于创建一个新的对象或者新的数组

Date now = new Date();
System.out.println(now);

运算符的优先级

运算符这里不用记忆，当不确定时，注意有个神器就是()小括号，可以使用它强制表达自己的编写意图

清风挽心ii

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录