java基础知识
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了java基础知识,小编现在分享给大家,供广大互联网技能从业者学习和参考。文章包含16260字,纯文字阅读大概需要24分钟。
内容图文
![java基础知识](/upload/InfoBanner/zyjiaocheng/596/139201ca170b402c9660a7280aa64e82.jpg)
一、数据类型
数据类型
整数类型:byte(1字节),short(2字节),int(4字节),long(8字节)【须带l】
浮点数类型:float(4字节)【须带f】,double(8字节)
字符类型:char(2字节)
布尔类型:boolean(1字节)
八进制0开头,十六进制0x开头
标识符
Java标识符(identifier)的构成规则:
以字母、下划线或美元符$开始
可以由以大写字母、小写字母、下划线或数字0~9组成。
常量
符号常量声明 : final 数据类型 常量名=缺省值;
final double PI=3.14159;
PI=3.1415 //错误
可以将一个整数赋值给字符型变量,例如 char m=97; m的值为’a’。
在Java中,变量如果没有初始化,编译器会提供初始值。具体来说,逻辑变量默认初始值是false;字符变量默认是空字符(码值为0的字符);整型变量默认值是0;小数变量默认值是0.0;用户自定义类型变量默认值是null。
数组
数组初始化
#数组元素类型 数组名[ ] = new 数组元素类型[数组元素的个数];
int intArray[ ] = new int[ ];
用new关键字为一个数组分配内存空间后,系统将为每个数组元素都赋予一个初值,这个初值取决于数组的类型。
所有数值型数组元素的初值为0,字符型数组元素的初值为一个不可见的控制符(’\u0000’),布尔型数组元素的初值为false,类的类型的数组在创建时,元素的初值为null。
数组对象一旦创建之后,在程序整个执行期间,就不能再改变数组元素的个数。
多维数组
int b[ ][ ] = new int[2][ ];// 最高维含2个元素,每个元素为一个一维整型数组
b[0] = new int[3]; // 最高维第一个元素是一个长度为3的整型数组
b[1] = new int[5];// 最高维第二个元素是一个长度为5的整型数组
int b[ ][ ]={{1,2},{2,3},{3,4}};//创建包含3行2列的二维数组,并给每个数组元素赋初值。
int c[ ][ ]={{2,3},{4,5,6}};//包含2行的二维数组c,第0行包含的元素个数为2,第1行包含的元素个数为3。
增强型for循环
增强型for循环只能用来取值,却不能用来修改数组里的值
public class HelloWorld {
public static void main(String[] args) {
int[] values = new int[] { 18, 62, 68, 82, 65, 9 };
//常规遍历
for (int i = 0; i < values.length; i++) {
int each = values[i];
System.out.println(each);
}
//增强型for循环遍历
for (int each : values) {
System.out.println(each);
}
}
}
二、运算符
&和&&都可以用作逻辑与的运算符,表示逻辑与(and),当运算符两边的表达式的结果都为true 时,整个运算结果才为true,否则,只要有一方为false,则结果为false。
&&还具有短路的功能,即如果第一个表达式为false,则不再计算第二个表达式。
&还可以用作位运算符,当&操作符两边的表达式不是boolean 类型时,&表示按位与操作。
三、分支与循环
if-else
if (条件表达式1) 语句1;
else if (条件表达式2) 语句2;
else if (条件表达式3) 语句3;
else 语句 n;
switch-case
switch (条件表达式)
{ case 常量表达式 1:语句1;
case 常量表达式 2:语句2;
┆
case 常量表达式 n:语句n;
default : 语句n+1;
}
while
while (条件表达式) 语句;
do-while
do 语句;
while (条件表达式);
for
for (表达式1;表达式2;表达式3) 语句
break
continue
return
四、常用方法
基本输入与输出
输入
//利用Scanner类输入
import java.util.*;
public class Example2_1 {
public static void main(String[] args) {
System.out.print("请输入一个整数:");
Scanner s = new Scanner(System.in);
int a = s.nextInt();
System.out.println("输入的数为:" + a);
}
}
输入的是一个整数,所以该程序使用了方法nextInt
,类似的还有nextLong
、nextFloat
、nextDouble
、nextBoolean
等。
输入一串字符串,可以使用nextLine、next()方法。next():读取一个字符串,该字符串在一个空白符之前结束。nextLine():读取一行文本(即以按下enter键为结束标志)。
//
public class Example2_2 {
public static void main(String args[]) {
int a, b, c;
a = Integer.parseInt(args[0]);
b = Integer.parseInt(args[1]);
c = a + b;
System.out.println("输入的两个参数的和为:" + c);
}
}
输出
标准输出
System.out.print(表达式);#紧凑格式
System.out.println(表达式);#会产生换行
格式化输出
int a=20,b=30;
System.out.printf(“a=%d,b=%d”,a,b); //a=20,b=30
System.out.printf(“%s %s”,”hello”,”world”); //hello world
Scanner
赋值后,has函数会读取下一个。
https://blog.csdn.net/gao_zhennan/article/details/80562548
五、类与对象
- 对象:对象是类的一个实例,有数据和方法。
- 类:类是一个模板,它描述一类对象的数据和方法。
在Java类的定义规范里面,有两方面内容来对应类中的数据和行为:
- 成员变量:用来描述对象的数据元素称为对象的属性(也称为数据/状态)。
- 成员方法:对对象的属性进行的操作称为对象的方法(也称为行为/操作)。
一个类可以包含以下类型变量:
- 局部变量:在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中,方法结束后,变量就会自动销毁。
- 成员变量:成员变量是定义在类中,方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
- 类变量:类变量也声明在类中,方法体之外,但必须声明为 static 类型。其作用域是整个类,可以直接用
类名.变量名
来引用,不需要产生类的具体实例。
定义类的语法格式:
[类的修饰符] class 类名 [extends 父类名] {
成员变量的定义;
成员方法的定义;
}
public class Dog {
String name;
String colour;
int age;
void eat() {
}
void run() {
}
void sleep(){
}
public theDog(){
}
}
public theDog()
为构造方法,与类同名。构造方法一般用于初始化某个类的对象构造方法没有返回类型,但可以有参数,并且可以重载。构造方法只能在创建对象时用new
命令调用。
每个类至少有一个构造方法,如果没有为类定义构造方法,系统会自动为该类生成一个默认的构造方法。默认构造方法的参数列表及方法体均为空,所生成的对象的数据成员的值也为零或空。如果程序员定义了一个或多个构造方法,则会自动屏蔽掉默认的构造方法。构造方法不能继承。
一个类的数据属性由它的成员变量的域(field)定义。在类中声明一个域的形式为:
[域修饰符] 类型 域名;
private int hour;
this:定义为被调用的方法的当前对象的引用。this
引用仅能出现在类中的方法体中。
类、成员的访问控制
类成员(静态成员)
将一个成员变量定义为类变量,只要将static关键字加在变量声明的前面。
private static int count = 0;
finalize方法与对象的销毁
在Java的Object类中提供了protected void finalize( ) ; 方法,任何Java类都可以覆盖finalize( )方法,在这个方法中释放对象所占有相关资源的操作。
当垃圾回收器将要释放无用对象的内存时,先调用该对象的finalize( )方法。若在程序终止前垃圾回收器始终没有执行垃圾回收操作,则垃圾回收器将始终不会调用无用对象的finalize( )方法。
//Point.java
public class Point{
private double x;
private double y;
public Point( ){
this(0,0);
}
public Point(double x,double y){
this.x=x;
this.y=y;
System.out.println("Point constructor:"+this);
}
protected void finalize( ){ //Point类的finalize方法
System.out.println("Point finalizer:"+this);
}
public String toString(){
return "["+x+","+y+"]";
}
}
//PointTest.java
public class PointTest{
public static void main(String args[ ]){
Point p1=new Point();
Point p2=new Point(2.5,2.5);
p1=null; //将引用变量p1、p2设置为null,使p1、p2原本指向的对象都变为无用对象
p2=null;
System.gc(); //调用System.gc( ),查看垃圾回收是否启动
System.out.println();
}
}
方法的重载(Overloading)
方法重载定义:在一个类中定义多个同名的方法,但要求各方法具有不同的参数的参数的类型或参数的个数。即:
参数的类型不同;或参数的顺序不同;或参数的个数不同。
Triangle( );不带参数,将使用默认值计算三角形的面积
Triangle(a,b);带两个参数,使用公式计算三角形的面积
Triangle(a,b,c);带三个参数,使用公式计算三角形的面积
六、类的继承和派生
Java类只支持单继承,而接口支持多继承。
在java中,Object类定义和实现了Java系统所需要的众多类的共同行为,它是所有类的根类。
[类修饰符] class 子类名 extends 父类名{
成员变量定义;
成员方法定义;
}
子类继承了父类中的除构造方法外的所有成员及方法。
equals()方法使用与继承
使用“==”只能判定两个对象是否使用同一空间。无法判定两个对象的内容是否相等。Object提供equals()方法用来判定两个对象的内容是否相等。equals()方法默认的是判定对象的空间地址相等,可以重载该方法来实现定制的相等判定规则。
枚举类型
Enum类是所有枚举类型的公共基本类,枚举类型enum是一个类块,在Java中所有的enum块的父类型是Enum类。
七、抽象类、接口、多态
抽象类
在Java语言中,使用abstract
修饰的类被称作抽象类,不能用它实例化一个对象,它只能被继承,反映现实世界中一个抽象的概念。
抽象方法只有方法头,或者叫方法的声明,而没有方法体。
抽象类中不一定包含抽象方法,但是包含抽象方法的类必须说明为抽象类。抽象方法也需要在方法头的前面使用关键字abstract
作为修饰符,在方法头的后面使用分号结束。
接口
定义接口使用的语句关键字为interface
。一个接口还可以继承一个或多个接口,所使用的子句关键字为extends
。
一个类可以实现一个或多个接口,所使用的子句关键字为implements
。如果一个接口定义中只包含有方法声明,不包含有成员变量定义,则称此为纯接口。
#声明接口
[修饰符] interface 接口名{
变量声明;
抽象方法声明;
}
#实现接口
[修饰符] class 类名 [extends 父类名] implements 接口名1 [,接口名2……]
{
类体
}
抽象类与接口的区别
1.抽象类可以有构造方法,接口中不能有构造方法。
2.抽象类中可以有普通成员变量,接口中没有普通成员变量
3.抽象类中可以包含非抽象的普通方法,接口中的所有方法必须都是抽象的,不能有非抽象的普通方法。
4. 抽象类中的抽象方法的访问类型可以是public,protected 和默认类型。但接口中的抽象方法只能是public 类型的,并且默认即为public abstract 类型。
5. 抽象类中可以包含静态方法,接口中不能包含静态方法
6. 抽象类和接口中都可以包含静态成员变量,抽象类中的静态成员变量的访问类型可以任意,但接口中定义的变量只能是public static final 类型,并且默认即为public static final 类型。
7. 一个类可以实现多个接口,但只能继承一个抽象类。
多态
八、异常
try
catch
finally
throw
throws
try后面可以跟任意个catch,但如果没有catch则必须有finally。
class JavaThrow
{ public static void main(String args[]){
try{
throw new ArithmeticException();
}
catch(ArithmeticException ae){
System.out.println(ae);
}
try{
throw new ArrayIndexOutOfBoundsException();
}
catch(ArrayIndexOutOfBoundsException ai){
System.out.println(ai);
}
try{
throw new StringIndexOutOfBoundsException();
}
catch(StringIndexOutOfBoundsException si){
System.out.println(si);
}
}
}
重新抛出异常对象的方法是在产生异常的方法名后面加上要抛出(throws)的异常列表:
//格式如右:returnType methodName([paramlist]) throws exceptionList
import java.io.*;
class JavaThrows {
public int compute(int x) throws ArithmeticException{
int z = 6/x; //可能抛出异常类型ArithmeticException 的对象
return z;
}
public void method1(){
int x;
try{
x=System.in.read(); //可能抛出异常类型IOException的对象;
x=x-48;
x=compute(x); //抛出异常类型ArithmeticException的对象
System.out.println(x);
}
catch(IOException ioe){ //捕获异常类型IOException的对象;
System.out.println("read error");
}
catch(ArithmeticException e){ //捕获异常类型ArithmeticException的对象
System.out.println("devided by 0");
}
}
public static void main(String args[]) {
JavaThrows t1=new JavaThrows();
t1.method1();
}
}
自定义异常同样要用try-catch-finally形式捕获处理,但异常对象必须由用户自己抛出(throw)。自定义异常的一般形式:
class MyException extends Exception
九、多线程
进程和线程的区别:
进程空间大体分为: 数据区,代码区,栈区,堆区。多个进程的内部数据和状态都是完全独立的;
1、栈区:主要用来存放局部变量, 传递参数, 存放函数的返回地址。
2、堆区:用于存放动态分配的对象。
3、数据区:全局,静态和常量是分配在数据区中的,数据区未初始化数据区和初始化数据区。
线程共享进程的数据区,代码区,堆区,只有栈区是独立的,所以线程切换比进程切换的代价小。
线程的状态与生命周期
一个线程的生命周期通常要经历五个状态:
- 创建状态(Born)
- 就绪状态或可运行状态(Ready)
- 运行状态(Running)
- 阻塞状态(Blocked,Waiting,Sleeping)
- 死亡状态(Dead)。
线程实现
1、继承Thread类
public class MyThread extends Thread{
@Override
public void run(){
System.out.println("线程开启");
}
}
public class MyThreadDemo{
public static void main(String[] args){
MyThread my = new MyThread();
my.start();//void start() 导致此线程开始执行; Java虚拟机调用此线程的run方法
}
}
2、实现Runable接口
public class MyRunable implements Runable{
@Override
public void run(){
System.out.println("线程开启");
}
}
public class MyRunableDemo{
public static void main(String[] args){
MyRunable my = new MyRunable();
Thread t = new Thread(my);
t.start();//void start() 导致此线程开始执行; Java虚拟机调用此线程的run方法
}
}
线程优先级与线程调度策略
线程的优先级
每个线程都有一个优先级(priority),数值范围:1~10
- Thread.MIN_PRIORITY(常量1,最低优先级)
- Thread.NORM_PRIORITY(常量值5,默认优先级)
- Thread.MAX_PRIORITY(常量10,最高优先级)
具有较高优先级的线程,完成的任务较紧急,因而应优先于较低优先级的线程分配处理器时间。
每个新创建线程均继承创建线程的优先级。
线程的优先级的设置或读取:用Thread对象的方法setPriority(int priority)
、用getPriority()
方法获得线程的优先级。
线程的调度策略
线程调度器(thread scheduler)支持一种抢先式的调度策略:当前线程执行过程中有较高优先级的线程进入就绪状态,则高优先级的线程立即被调度执行。
线程的创建和执行
在程序中实现多线程有两种方式:创建Thread类的子类或实现Runnable接口。
这两种方式都要两个关键性的操作: 定义用户线程的操作,即实现线程的run( )方法的方法体; 构造Thread类对象,实现线程的建立和运行控制。
IO流
字节流
字节流写数据
public class FileOutputStreamDemo02{
public static void main(String[] args) throws IOException{
//创建字节输出流对象(调用系统功能创建了文件,创建字节输出流对象,让字节输出流对象指向文件)
FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");
//打包数据
byte[] bys = "abcde".getBytes();
//调用字节输出流对象的写数据方法
//void write(byte[] b, int off, int len):将 len字节从指定的字节数组开始,从偏移量off开始写入此文件输出流
fos.write(bys,1,3);
//释放资源(关闭此文件输出流并释放与此流相关联的任何系统资源)
fos.close();
}
字节流读数据
public class FileInputStreamDemo01{
public static void main(String[] args) throws IOException{
//创建字节输入流对象
FileInputStream fis = new FileInputStream("myByteStream\\fos.txt");
int by;
/*
fis.read():读数据
by=fis.read():把读取到的数据赋值给by
by != -1:判断读取到的数据是否是-1
*/
while ((by=fis.read())!=-1) {
System.out.print((char)by);
}
//释放资源
fis.close();
}
}
字节缓冲流
- BufferOutputStream:该类实现缓冲输出流。 通过设置这样的输出流,应用程序可以向底层输出流写入字节,而不必为写入的每个字节导致底层系统的调用
- BufferedInputStream:创建BufferedInputStream将创建一个内部缓冲区数组。 当从流中读取或跳过字节时,内部缓冲区将根据需要从所包含的输入流中重新填充,一次很多字节
public class CopyAviDemo{
public static void main(String[] args) throws IOException{
//记录开始时间
long startTime = System.currentTimeMillis();
//复制视频
// method1();
// method2();
// method3();
method4();
//记录结束时间
long endTime = System.currentTimeMillis();
System.out.println("共耗时:" + (endTime - startTime) + "毫秒");
}
//字节缓冲流一次读写一个字节数组
public static void method4() throws IOException{
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\itcast\\字节流复制图片.avi"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myByteStream\\字节流复制图片.avi"));
byte[] bys = new byte[1024];
int len;
while ((len=bis.read(bys))!=-1) {
bos.write(bys,0,len);
}
bos.close();
bis.close();
}
//字节缓冲流一次读写一个字节
public static void method3() throws IOException{
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\itcast\\字节流复制图片.avi"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myByteStream\\字节流复制图片.avi"));
int by;
while ((by=bis.read())!=-1) {
bos.write(by);
}
bos.close();
bis.close();
}
//基本字节流一次读写一个字节数组
public static void method2() throws IOException{
//E:\\itcast\\字节流复制图片.avi
//模块目录下的 字节流复制图片.avi
FileInputStream fis = new FileInputStream("E:\\itcast\\字节流复制图片.avi");
FileOutputStream fos = new FileOutputStream("myByteStream\\字节流复制图片.avi");
byte[] bys = new byte[1024];
int len;
while ((len=fis.read(bys))!=-1) {
fos.write(bys,0,len);
}
fos.close();
fis.close();
}
//基本字节流一次读写一个字节
public static void method1() throws IOException{
//E:\\itcast\\字节流复制图片.avi
//模块目录下的 字节流复制图片.avi
FileInputStream fis = new FileInputStream("E:\\itcast\\字节流复制图片.avi");
FileOutputStream fos = new FileOutputStream("myByteStream\\字节流复制图片.avi");
int by;
while ((by=fis.read())!=-1) {
fos.write(by);
}
fos.close();
fis.close();
}
}
字符流
字符流复制文件
public class CopyJavaDemo02{
public static void main(String[] args) throws IOException{
//根据数据源创建字符输入流对象
FileReader fr = new FileReader("myCharStream\\ConversionStreamDemo.java");
//根据目的地创建字符输出流对象
FileWriter fw = new FileWriter("myCharStream\\Copy.java");
//读写数据,复制文件
// int ch;
// while ((ch=fr.read())!=-1) {
// fw.write(ch);
// }
char[] chs = new char[1024];
int len;
while ((len=fr.read(chs))!=-1) {
fw.write(chs,0,len);
}
//释放资源
fw.close();
fr.close();
}
}
字符缓冲流复制文件
public class CopyJavaDemo01{
public static void main(String[] args) throws IOException{
//根据数据源创建字符缓冲输入流对象
BufferedReader br = new BufferedReader(new FileReader("myCharStream\\ConversionStreamDemo.java"));
//根据目的地创建字符缓冲输出流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\Copy.java"));
//读写数据,复制文件
//一次读写一个字符数据
// int ch;
// while ((ch=br.read())!=-1) {
// bw.write(ch);
// }
//一次读写一个字符数组数据
char[] chs = new char[1024];
int len;
while ((len=br.read(chs))!=-1) {
bw.write(chs,0,len);
}
//释放资源
bw.close();
br.close();
}
}
内容总结
以上是互联网集市为您收集整理的java基础知识全部内容,希望文章能够帮你解决java基础知识所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错,欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 gblab@vip.qq.com 举报,一经查实,本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。