java基础

最新推荐文章于 2024-11-01 14:48:20 发布

烟雨平生、赵

最新推荐文章于 2024-11-01 14:48:20 发布

阅读量287

点赞数

分类专栏： java 文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/weixin_45454852/article/details/122278570

版权

java 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

Java基础

JDK: Java 2 SDK (Development Kit)包含：JRE的超集，包含编译器和调试器等用于程序开发的文件.
JRE: Java Runtime Environment ( JRE) 包含：Java虚拟机、库函数、运行Java应用程序和Applet所必须文件
Java运行环境的三项主要功能：
- 加载代码：由class loader 完成；
- 校验代码：由bytecode veriﬁer 完成；执行代码：由 runtime interpreter完成。
- 区别和联系：
  - sdk（也就是jdk）是jre的超集，是在jre的基础上增加了编译器及其他一些开发工具。
  - jre就是java运行时环境，包括了jvm和其它一些java核心api，任何一台电脑，只有安装了jre才可以运行
java程序:如果只是要运行JAVA程序，之需要JRE就可以。 JRE通常非常小，也包含了JVM.如果要开发JAVA程序，就需要安装JDK。
JVM是指在一台计算机上由软件或硬件模拟的计算机；它类似一个小巧而高效的CPU。

JVM负责将java字节码解释运行，边解释边运行，这样，速度就会受到一定的影响。JAVA提供了另一种解释运行的方法JIT（just in time），可以一次解释完，再运行特定平台上的机器码，高级的JIT可以只能分析热点代码，并将这些代码转成本地机器码，并将结果缓存起来，下次直接从内存中调用，这样就大大提高了执行JAVA代码的效率。这样就实现了跨平台、可移植的功能。
byte-code代码是与平台无关的是虚拟机的机器指令。

java字节代码运行的两种方式:

方式interpreter(解释)

Just-in-time(即时编译):由代码生成器将字节代码转换成本机的机器代码,然后可以以较高速度执行。JAVA的跨平台实现的核心是不同平台使用不同的虚拟机不同的操作系统有不同的虚拟机。Java 虚拟机机制屏蔽了底层运行平台的差别，实现了“一次编译，随处运行”。
JVM（JAVA Virtual Machine）是一种规范，可以使用软件来实现，也可以使用硬件来实现，就是一个虚拟的用于执行bytecodes字节码的计算机。他也定义了指令集、寄存器集、结构栈、垃圾收集堆、内存区域。 Java语言虽然比较接近解释型语言的特征，但在执行之前已经预先进行一次预编译，生成的代码是介于机器码和Java源代码之间的中介代码，运行的时候则由JVM（Java的虚拟机平台，可视为解释器）解释执行。它既保留了源代码的高抽象、可移植的特点，又已经完成了对源代码的大部分预编译工作，所以执行起来比“纯解释型”程序要快许多。

第一步：编译

利用编译器（javac）将源程序编译成字节码à 字节码文件名：源文件名.class
第二部：运行

利用虚拟机（解释器，java）解释执行class字节码文件。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fkT8VxaI-1641116600813)(C:\Users\yanyu\AppData\Roaming\Typora\typora-user-images\image-20211227164519511.png)]

JavaDoc

1、简介

JavaDoc是一种将注释生成HTML文档的技术，生成的HTML文档类似于Java的API，易读且清晰明了。在简略介绍JavaDoc写法之后，再看一下在Intellij Idea 中如何将代码中的注释生成HTML文档。

javadoc是Sun公司提供的一个技术，它从程序源代码中抽取类、方法、成员等注释形成一个和源代码配套的API帮助文档。也就是说，只要在编写程序时以一套特定的标签作注释，在程序编写完成后，通过Javadoc就可以同时形成程序的开发文档了。javadoc命令是用来生成自己API文档的，使用方式：使用命令行在目标文件所在目录输入javadoc +文件名.java。

先看一段样例代码：

/** 这是一个Javadoc测试程序
 *	@author Kuangshen 
 *	@version 1.0
 *	@since 1.5
 ** */

public class HelloWorld {

	public String name;
    /**
    * @param name 姓名
    * @return 返回name姓名
    * @throws	Exception 无异常抛出
    * */
	public String function(String name) throws Exception{
		return name;
	}
}

稍微解释一下：

以 /*** 开始，以 / 结束。

@author 作者名

@version 版本号

@since 指明需要最早使用的jdk版本

@param 参数名

@return 返回值情况

@throws 异常抛出情况

2、命令生成

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zB3kBx0X-1641116600814)(C:\Users\yanyu\AppData\Roaming\Typora\typora-user-images\image-20211227164225720.png)]

-encoding UTF-8 -charset UTF-8
//解决GBK乱码问题，在中间添加编码设置

java面向过程

1.数据类型
1.1基本数据类型
                            默认值		字节数
整数:      byte     8        0			1
          short    16        0			2
           int     32        0			4
          long     64        0l			8
 实型:      float   32        0.0f		4
            double  64       0.00		8
 字符型:     char    16        0		1
( 转义字符省略)
 布尔型:     boolean  true        false
 
 1.2引用数据类型
	除了基本类型之外的全是引用类型

 为什么学习数据类型?
 计算机他自己对于超出范围的数据没有处理能力.

1.3运算符
 (1).双目运算符 :+ - * /
 	对象:针对整数和实型
 	注意：
 	 例1：
 	 int a=2147483647*2;//结果a=-2
 	 long a=2147483647*2;//结果a=-2
 	 long a=2147483647*2L;//结果a=4294967294
 	 结论常整数相乘 结果是int类型，需要类型强转。
 	 例2：
 	 整数与整数相除，精度损失。3/2=1；
(2)单目运算符++ -- + -
 	对象:针对整数和实型
(3)赋值运算符：=

重点:

强制类型转换
变量名 =(类型名) 表达式;

类型自动转换


(4).关系表达式
 >   >=   <   <=   ==  !=
instanceof ( 用于判断前者是否为后者的实例 )

boolean is= 对象名 instanceof 类名;
真 返真 假 返假
 
(5).逻辑表达式
! && || ^(异或)

(6).位运算符表达式
按位取反: ~
按位与 :　＆
按位或　：｜
按位异或：＾
有符号左移：＜＜
有符号右移：＞＞
无符号左移：＜＜＜
Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。

位运算符作用在所有的位上，并且按位运算。假设a = 60，b = 13;它们的二进制格式表示将如下：
A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~A= 1100 0011
下表列出了位运算符的基本运算，假设整数变量 A 的值为 60 和变量 B 的值为 13：

操作符	描述	例子
＆	    如果相对应位都是1，则结果为1，否则为0	（A＆B），得到12，即0000 1100

|	    如果相对应位都是 0，则结果为 0，否则为 1	（A | B）得到61，即 0011 1101

^	    如果相对应位值相同，则结果为0，否则为1	（A ^ B）得到49，即 0011 0001

〜	    按位取反运算符翻转操作数的每一位，即0变成1，1变成0。	（〜A）得到-61，即1100 0011

<< 	按位左移运算符。左操作数按位左移右操作数指定的位数。	A << 2得到240，即 1111 0000

>> 	按位右移运算符。左操作数按位右移右操作数指定的位数。	A >> 2得到15即 1111

>>> 	按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。	A>>>2得到15即0000 1111

(7).运算符优先级
   １　（）［］　．　new
  ２　～　！　++　--　+　-                    自右向左
   ３　* / %
   4 + -
   5 << >> <<<
   6 > >= < <=  instanceof
   7 == !=
   8 &
   9 ^
   10 |
   11 &&
   12 ||
   13 ?:                                     自右向左
   14 = += -= += %= /= <<= >>= <<<= ^= \= &= 自右向左


3.程序语句
控制语句与C++一致.

4.函数
返回值 函数名（形参列表）      
{
	函数体

}                                                  

重点：
参数传递
（1）基本类型参数
	值传递
（2）引用类型参数
	地址传递


 
   
}

java面向对象

下面展示一些 内联代码片。

类入门
1.package的相关使用
文件夹层次结构，其实就是文件夹，每有一个"."就是跳入下一个文件夹，这种包其实就是为了方便管理类.
2.import语句导包
格式: import 包名.类名;
注意:(1).import语句要位于package语句之后
(2).类名可以用"*"代替, 指导入包内所有类. 但import java.awt.*; 不能导入java.awt.event;包中的类.
(3).java源程序默认引入java.lang.*; 因此该包所有类均可使用.
总结: 类似#include <>, 同样是导入工具包, 只是形式不同.
(4). 导包其实是根据"classpath"(也就是常说的环境变量配置的原因)路径找jar包。

3.类的定义
3.1定义形式:
[public] [abstract|final] class 类名[extends 父类名][implements 接口列表]  //类首部
{
定义成员变量;//用于描述静态属性
定义构造方法;//一般对于成员变量初始化
定义成员方法;//用于描述动态行为
}

说明:
(1). []表示可选, | 表示二选一
(2). public是访问控制修饰符, 表示该类为公共类, 即所有类均可访问它.
 若省略public表示其访问级别为默认级别, 此时只有同包的类可以访问它,此时只用同包的类可以访问它.
 一个源程序文件可以定义多个类, 但是只能有一个public的类,而且文件名与类名要一致.
 若希望一个包中的所有类均为public类型, 应在不同的.java文件中定义,
 当然此时每个文件开始都要使用package语句声名它们处在同一个包.
(3). 类内部成员定义一般都要加上访问限制修饰符。
3.2对象创建和对象的引用
	创建对象: 类名 对象名称 = new 类名(参数列表);
//与C++基本一致.
3.3成员变量
定义形式:
	[访问控制符] [static] [final] 类型名 变量名列表;
(1). final常量修饰符, 定义时初始化.//初始化在类定义时或者构造函数初始化
(2). static静态成员, 静态成员属于所有对象共有, 基本与C++一致, 但也有不同之处.
 推荐访问方式, 类名.静态成员;
 初始化在类定义时


附访问控制符
--------------------------------------------------------------------------------------------
  |    同类中    |   同包中    |    不同包子类中    |    不同包非子类中
--------------------------------------------------------------------------------------------
private |      /      |      X     |        X         |        X
--------------------------------------------------------------------------------------------
默认    |      /      |      /     |        X         |        X
--------------------------------------------------------------------------------------------
protect |      /      |      /     |        /         |        X
--------------------------------------------------------------------------------------------
public  |      /      |      /     |        /         |        /
--------------------------------------------------------------------------------------------
此外强调, 在一个类中调用另外一个类, 这个类必须是public类型, 否则不行.

4.构造方法
(1).基本与C++一致.
但是   他的构造函数和普通函数一样, 必须要有访问控制符public来修饰, 这样才能为对象创建所调用，必须要有空参构造（默认构造）.

5.成员函数
定义格式:
[修饰符]返回值类型 函数名( 形参列表 ) [throws 异常列表]
{
函数定义;
}
(1).修饰符可以是 访问控制符   static   final   abstract    native   synchronized 等作为方法的修饰符
(2).static  修饰  与C++一致, 静态函数方法.
(3).final为最终方法, 不能被重载.
(4).abstract 是抽象方法.与static不能共存.
(5)synchronized是多线程控制的.

此外, 方法名称数据访问和修改, 固定格式, get   set   , 驼峰式.

以及, 方法重载, 与C++一致, 参数列表个数或类型不一致, 则为方法重载, 注意, 形参列表一致, 而返回值不同, 不是方法重载.
6.继承
6.1继承的概念
java只支持单继承
 
6.2继承的实现
基本格式:
class B extends A
 
{
	...
}
说明:
(1).未使用extends指定父类,默认继承java.lang.Object
(2).子类继承父类的private时,只是访问受限.
(3).构造方法并不属于父类的方法,不能被继承.
(4).构造函数一定要有一个无参构造.

6.3方法重写和属性隐藏
说明:
(1).访问控制符控制访问属性,根据需要使用.
(2).重写时不能减小函数访问范围.
(3).final所修饰的函数不能被重写.
(3).注意区别方法重载和方法重写的区别,方法重写是与父类参数返回值等等参数均一致多情况下重写.*而方法重载是形参列表的不同.
(4).在子类可以使用super.方法名(形参列表)调用父类方法.
(6).父类和子类里面可以建立相同名字的函数,或者变量,但是这样会让父类的函数或变量隐藏起来,当然也是可以调用的,
只要用super关键字.
 
6.4关键字super和this
说明:
(1).this类比C++.(自己的地址)
(2).super,父类的地址.
主要是构造函数用,以及调用父类成员.

7.抽象类
在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类
 
格式:
public abstract class类名
{
构造方法;
成员变量;
成员函数;
}
注:(1).基本与普通类一致,但是构造方法可使用,不能实例化.
(2).被继承后所有的抽象函数必须实例化(重写).
8.继承性和多态性
继承性:
通过继承的方式让代码重用.
多态性:
不同类的对象可以对同一个消息做出反应,体现在java就是不同类对象的函数调用同名方法,结果不同.
 
9.接口
9.1接口的定义
格式:
public [abstract] interface接口名 [extends父类接口列表]
{
...
}
说明:
(1).访问控制符只能是public或者省略.
(2).abstract可以省略,extends表示接口可以多继承.
(3).接口中的变量默认以public static final修饰,可不写,意味着接口中只有常量.
(4).接口中函数默认一以public abstract修饰,但从javase8允许接口中定义以default修饰的非抽象方法和以static修饰静态方法.
(5).接口中无构造方法.
(6).接口也可以用instanceof 运算符判断该类是否实现了该接口。
9.2接口和多态
接口不能实例化,但是可以定义接口引用.
接口名  接口引用名;
接口引用可以指向任意一个实现它的类的对象,类似父类引用指向不同子类对象.

(子类是对父类的一个改进和扩充，所以一般子类在功能上较父类更强大，属性较父类更独特，定义一个父类类型的引用指向*一个子类的对象既可以使用子类强大的功能，又可以抽取父类的共性。所以，父类类型的引用可以调用父类中定义的所有属性
和方法，而对于子类中定义而父类中没有的方法，父类引用是无法调用的；
那什么是动态链接呢？当父类中的一个方法只有在父类中定义而在子类中没有重写的情况下，才可以被父类类型的引用调用；对于父类中定义的方法，如果子类中重写了该方法，那么父类类型的引用将会调用子类中的这个方法，这就是动态连接。)

10.嵌套类

类里面又是另一番天地,想怎么定义就怎么定义呗.
注意：由于java的垃圾回收机制，导致匿名类的出现，也就是申请内存不用管释放。 
11.枚举

 
 
番外篇
 
static 变量和方法
 
. 静态方法如何调用？
java 用“ . ”运算符
C++ 用“：：”或者 “  .  ”
. 静态方法不能调用普通成员方法？
在静态方法是在类加载的时候就已经编译了，而实例方法必须有实例的清空下才能使用。
 
final  
能用一定用上， 防止别人篡改数据， 或者别的。很有用的。
C++用const

java一些类

1.Object类
	Class Object是类Object结构的根。 每个班都有Object作为超类。 所有对象（包括数组）都实现了这个类的方法。
	1.1构造方法
	public Object()
	
	1.2具体方法
	public final class<?> getClass()；
	返回此Object的运行时类。
	public String toString()
	对象的字符串表示形式。
	public int hashCode()
	返回对象的哈希码值。 支持这种方法是为了散列表，如HashMap提供的那样 。
	public boolean equals(Object obj)
	指示一些其他对象是否等于此。（根据hashCode（））
	getClass().getName() + '@' + Integer.toHexString(hashCode())
	

------------------------------------------------------------------------------

	protected void finalize()
                 throws Throwable
    当垃圾收集确定不再有对该对象的引用时，垃圾收集器在对象上调用该对象。
	void notify()
	唤醒正在等待对象监视器的单个线程。
	void notifyAll()
	唤醒正在等待对象监视器的所有线程。
	void wait()
	导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 		notifyAll()方法。
	void wait(long timeout)
	导致当前线程等待，直到另一个线程调用 notify()方法或该对象的 		notifyAll()方法，或者指定的时间已过。
	void wait(long timeout, int nanos)
	导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法，或者某些其他线程中断当前线程，或一定量的实时时间。



2.String类
成员变量：

静态成员变量：

构造函数：

功能函数：

静态函数：

小技巧：
1.解决字符乱码问题
public byte[] getByes(String charsetName);//获取指定字符串给定编码格式二进制形式
public  String(byte bytes[], String charsetNmae);//按照charsetName编码格式解读bytes字符串二进制
这两个函数相互配合，循环测试。
3.