JAVASE--学习日志

最新推荐文章于 2024-07-14 23:44:12 发布

少熬夜活得久

最新推荐文章于 2024-07-14 23:44:12 发布

阅读量124

点赞数

文章标签：学习 java jvm

本文链接：https://blog.csdn.net/weixin_64274578/article/details/125412701

版权

一、Java基础知识

1.注释

目的：解释代码，或者使错误的、没必要的代码失效，或者作为规范，使效率更高。

格式：

a.单行注释：“//……”

b.块注释：“/*……*/”

c.档注释：“/**……*/”

d.注释标签语法 :@author 对类的说明标明开发该类模块的作者

2.标识符和关键字

用来标志类名、变量名、方法名、类型名、数组名、文件名的有效字符序列称为标志符。简单地说，标志符就是一个名字。

例如，First_aa、ChinaYear_2018、$98、hello,而98ab不是。

关键字是 Java 语言中已经被赋予特定意义的一些单词，它们在程序上有着不同的用途，关键字不可以作为名字被使用。 Java 的50个关键字如下：
abstract assert boolean break byte case catch char class const continue default do double else enum extends final finally float for goto if implements import instanceof int interface long native new package private protected public return short static strictfp super switch synchronized this throw throws transient try void volatile while

3.数据类型

基本数据类型也称为简单数据类型。 Java 语言有8种简单数据类型： boolean , byte , short , int , long , float , double , char 。这8种数据类型习惯上被分为四大类型：①逻辑类型， boolean ;
②字符类型， char ;③整数类型， byte 、 short 、 int 、 long ;④浮点类型， float 、 double 。

具体详情如下：

1，逻辑类型
常量： true , false
变量的定义：使用关键字 boolean

来定义逻辑变量，定义时也可以赋给初值，如
boolean %, ok = true ，关闭= false ;

2．整数类型
常量：123,6000（十进制数）,077（八进制数）,Ox3ABC（十六进制数）。
整型变量的定义分为如下4种。

(1) int 类型
使用关键字 int 来定义 int 类型整型变量，定义时也可以赋予初值，如
intX =12，平均＝9898, jiafei ;
对于 int 类型变量，内存分配4字节（ byte )。1字节包括8位（ bit ),4字节占32位（ bit )。 bit 有两种状态，分别用来表示0和1。这样计算机就可以使用二进制数来存储信息了。对于int X=7;
内存存储状态为“00000000 00000000 00000000 00000111”。
最高位（左边的第一位）是符号位，用来区分正数或负数。正数使用原码表不，最高位是0。负数用补码表示，最高位是1，如 int x=7;
内存的存储状态为“11111111111111111111111l11111000”
要得到﹣8的补码，首先得到7的原码，然后将7的原码中的0变成、1变成0，就是-8的补码。因此， int 类型变量的取值范围是-2^31~2^31-1。

(2) byte 类型
使用关键学 byte 来定义 byte 类型整型变量。对于 byte 类型变里，内仔分配1字节，占8位。 byte 类型变量的取值范围是-2^7~2^7-1，如
byte X =-12, tom=28，漂亮=98;

(3) short 类型
使用关键字 short 来定义 short 类型整型变量。对于 short 类型变量，内存分配2字节，占
16位。 short 类型变量的取值范围是-2^15~2^15-1，如
short X =12, y =1234;

(4) long 类型
使用关键字 long 来定义 long 类型整型变量。对于 long 类型变量，内存分配8字节，占
64位， long 类型变量的取值范围是-2^63~2^63-1，如
long month =12, year =200s, jiafei ;

3．字符类型
常量： Unicode 表中的字符就是一个字符常量，如 A '、 b 、”?、''、9、好、'き＇、'モ等。有些字符（如回车符）不能通过键盘输入到字符串或程序中，这时需要使用转意字符常量，如 n '（换行）、' b （退格）、 t ’（水平制表）、"（单引号）、"（双引号）。例如，字符串
“我喜欢使用双引号：'\＂'＂
含有双引号字符，但是下面的就是一个非法字符串
“我喜欢使用双引号：＂”
变量的定义：使用关键字 char 来定义字符变量，如
char X =' A , tom =‘家，漂亮＝‘假’, jiafei ;
char 类型变量内存分配给2字节，占16位，最高位不是符号位，没有负数。 char 类型变量的取值范围是0~65535。对于 char X =' a ＇;
内存中存储的是97,97是字符 a '在 Unicode 表中的排序位置。因此，允许将上面的语句写成 char X =97;
要观察一个字符在 Unicode 表中的顺序位置，必须使用 int 类型显式转换，如（ int )' a ’。不可以便用 short 类型转换，因为 char 的最高位不是符号位。同样，要得到一个0~65535之间的数所代表的 Unicode 表中相应位置上的字符，也必须使用 char 类型显式转换。

4．浮点类型浮点型分为两种。

(1) float 类型
常量：453.5439f,21379.987F,231.0f,2e40f(2乘10的40次方，科学计数法）。
变量的定义：使用关键字 float 来定义 float 类型变量。对于 float 类型变量，内存分配4字节，占32位。 float 类型变量的取值范围是10^-38~10^38和-10^38~-10^-38恐，如
float X =22.76f, tom =1234.987f，漂亮＝9876.0f, jiafei ;

(2) double 类型
常量：21389.5439d( d 可以省略）,23189908.987,123.0,6e-140(6乘10的﹣140次方，科学计数法）。
变量的定义：使用关键字 double 来定义 double 类型变量。对于 double 类型变量，内存分配8字节，占64位。 double 类型变量的取值范围是10^-308~10^308和﹣10^308-10^-308，如
doubleX -12.76, ton =1234098.987，漂亮＝9876.098d, jiafei ;

4.数据类型的转换

当把级别低的变量的值赋给级别高的变量时，系统自动完成数据类型的转换。

当把级别高的变量的值赋给级别底的变量时，必须使用显示类型转换运算符，如：

int x=（int ）34.19;

5.常量，变量，作用域

1.常量

a.字符串常量：用双引号引起来的部分，叫做字符串常量。例如：“abc”、“Hello”、“123”
b.整数常量：整数。例如：100、200、0、-350
c.浮点数常量：小数。例如：2.5、-3.14、0.0
d.字符常量：用单引号引起来的单个字符，就叫做字符常量。例如：‘A’、‘b’、‘9’、‘中’
e.布尔常量：true、false。
f.空常量：null。代表没有任何数据。

2.变量

变量用于表示在程序中可能被改变的值。

int a;
a=1;
a=2;//a就是变量

3.作用域

在Java中，经常看到public、protected、private这些修饰符，这些修饰符可以用来限定访问作用域。

（1）public

定义为public的类(class)、接口(interface)可以被其它任何类访问。

定义为public的字段(field)、方法(method)可以被其它类访问，前提是首先有访问class的权限。

（2）private

定义为private的字段(field)、方法(method)无法被其他类访问。实际上，private访问权限被限定在类(class)的内部，而且与方法声明顺序无关。

推荐把private方法放到后面，因为public方法定义了类对外提供的功能。

由于Java支持嵌套类，如果一个类内部还定义了嵌套类，那么嵌套类拥有访问private的权限。定义在一个class内部的class称为嵌套类(nested class)。

(3)protected

protected作用于继承关系。定义为protected的字段和方法可以被子类访问，以及子类的子类。

（4）package

包作用域是指一个类允许访问同一个package的没有public、private修饰的class，以及没有public、protected、private修饰的字段和方法。

只要在同一个包，就可以访问package权限的class、field和method。

注意：包名必须完全一致，包没有父子关系，com.apache和com.apache.abc是不同包。

（5）局部变量

在方法内部定义的变量称为局部变量，局部变量作用域从变量声明处开始到对应的块结束。方法参数也是局部变量。

使用局部变量时，应该尽可能把局部变量的作用域缩小，尽可能延后声明局部变量。
for(int i=0;i<10;i++){
//这里声明的i只能在for循环里作用
}
（6）final

Java提供了一个final修饰符，final与访问权限不冲突，它有很多作用：

用final修饰class可以阻止被继承；

用final修饰method可以阻止被子类覆写；

用final修饰field可以阻止被重新赋值；

用final修饰局部变量可以阻止被重新赋值。

6.运算符和表达式

1.基本运算符

+（加）, -（减）, *（乘），/（除）【注意：整数与整数相除，整数与小数相除，小数与小数相除，它们之间的区分度】，%（取余），！（非）

2.关系运算符

=，<，>，<=，>=，==（等于），!=（不等于）

3.逻辑运算符

&&（与）两个都是真，结果才能为真，||（或）一个为假便都是假。

4.赋值运算符

=（赋值给）

5.移位运算符

必须是整数类型，用来对二进制进行操作。

都是双目运算符。

a.左移运算符（<<）如m<<n就是将m的所有位置都进行左移n位，最高位上的0或者1被丢弃，右边用0来填充。

b右移运算符（>>）如m>>n就是将m的所有位置都进行右移n位，最低位上的0或者1被丢弃，左边用0来填充。

6.位运算符

a.按位与（&）

&是双目运算符，对两个整型数据 a 、 b 按位进行运算，运算结果是一个整型数据 c 。如果 a 、 b 两个数据对应位都是1，则 c 的该位是1，否则是0。如果 b 的精度高于a，那么结果 c 的精度和 b 相同。

b.按位或（|）

| 是双目运算符，对两个整型数据 a 、 b 按位进行运算，运算结果是一个整型数据 c。法则是：如果 a 、 b 两个数据对应位都是0，则 c 的该位是0，否则是1。如果 b 的精度高于a，那么结果是c的精度和b相同。

c.按位非（~）

～是单目运算符，对一个整型数据 a 按位进行运算，运算结果是一个整型数据 C 。运算法则是：如果 a 对应位是0，则 c 的该位是1，否则是0。

d.按位异或（^）

^是双目运算符，对两个整型数据 a 、 b 按位进行运算，运算结果是一个整型数据 C 。
去则是：如果 a 、 b 两个数据对应位相同，则 c 的该位是0，否则是1。如果 b 的精度高于a,那么结果 c 的精度和 b 相同。

7.条件运算符

？：（三目运算符）

a?b:c(如果a是对的，则结果是b；如果a是错的，则结果是c)

8.自增，自减

a++;先a本身，再a+1;

++a;先a+1;

a--;先a本身，再a-1;

--a;先a-1;

二、流程控制

1.Scanner类输入

引入了java.util.Scanner类，主要用于扫描用户从控制台输入文本的程序。即当用户需要输入数据时，调用java.util包中的Scanner类，Scanner类能获取用户所输入的数据。

import java.util.Scanner;//先导入包

Scanner reader=new Scanner(System.in);//创建reader对象

需要创建变量来接收数据

int a=sc.nextInt();

double b=sc.nextDouble();

float c=sc.nextFloat();

String s=sc.next();

nextXxx():即获取下一个输入项。其中Xxx表示所要输入的数据的类型，比如Int、Long、Double…等基本数据类型。
hasNextXxx()：是否还有下一个输入项。
Java中next（）只能获取空格之前的数据

2.语句结构

1.if语句

if语句:用于判断,可以单分支,也可以多分支

单分支:

if(判断语句){

//满足,则执行的代码块

}else{

//不满足判断语句时,执行的代码块

}

多分支:

if(判断语句1){

//满足判断语句1,执行的代码块

}else if(判断语句2){

//不满足判断语句1,满足判断语句2,执行代码块

}else{

//既不满足语句1,也不满足语句2,执行的代码块

}

if语句不一定在使用的时候要和else配套使用.

当if只执行一条语句时,不需要用大括号{}包起来,这条语句后面的分号;意味着if语句的结束.

当如果想让if()执行多条语句,就必须有{}括起来,这个时候,if语句结束不需要用;.因为{}的结束就意味着if语句的结束.

if(a==1){a++;}
else {b++;}

2.switch选择结构

switch简单使用的场景一般都是处于分支结构中,当题目中需要进行多次分支时,并且借助if 语句使用复杂时, 那么这种情况可以考虑一下switch语句。

swtich(表达式)  {    //   ()中的数据类型仅仅支持整数
                 case 常量1 :
                   要执行的语句;
                   break;
                 case 常量2 :
                   要执行的语句;
                   break;
                 case 常量3 :
                   要执行的语句;
                    break;
                 default:
                   要执行的语句;
                   break;
}

3.while循环

while语句格式：

while(条件表达式)

{

执行语句；

}

4.do while循环

do-while声明时,至少一次会循环一次

格式：

{

循环体语句;

}while( 循环条件 );

5.for循环

for(初始化; 表达式1; 表达式2) {

//代码语句

}

6.break,continue,goto

1.break语句功能：

A. switch语句中，break语句会终止其后语句的执行，退出switch语句。

B. 使一个循环立即结束，也就是说在循环中遇到break语句时，循环立即终止，程序转到循环体后的第一个语句去继续执行。

2.continue语句功能：

它只能出现在循环体中，其功能是立即结束本次循环，即遇到continue语句时，不执行循环体中continue后的语句，立即转去判断循环条件是否成立。

3.goto语句形式：

goto语句是无条件转向语句，其一般形式为：goto 语句标号;

goto语句往往用来从多重循环中跳出。它在解决一些特定问题时很方便，但由于goto语句难于控制，尽量少用。

三、Java方法

1.Java方法的含义和调用

Java的方法类似于其他语言的函数，是一段用来完成特定功能的代码片段，一般情况下，定义一个方法包含以下语法：
方法包含一个方法头和一个方法体。下面是一个方法的所有部分：
修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
返回值类型：方法可能会返回值。returnValueType是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。这种情况下，returnValueType是关键字void。
方法名：是方法的实际名称。方法名和参数表共同构成方法签名。
参数类型：参数像是一个占位符。当方法被调用时，值传递给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
形式参数：方法被调用时用于接收外界输入的数据。
实参：调用方法时实际传给方法的数据。
方法体：方法体包含具体的语句，定义该方法的功能。

修饰符 返回值类型 方法名 (参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}

调用方法：对象名.方法名（实参列表）

Java支持两种调用方法的方式，根据方法是否返回值来选择。

当方法返回一个值的时候，方法调用通常被当做一个值。

2.方法的重载

Java中的方法重载，在一个类中，可以存在多个方法名相同的方法，但是参数列表不同。同一个类中定义的多个方法之间的关系，满足下列的多个方法互相构成重载：

1.多个方法在同一个类中。
2.多个方法具有相同的方法名。
3.多个方法的参数不相同，类型不同或者数量不同。

//参数数量不同
public class text1 {
    public static void main(String[] args) {
        show(1);
        show(1,2);
    }
    public static void show(int a){
        System.out.println(a);
    }
    public static void show(int a ,int b){
        System.out.println(a + " " + b);
    }
//参数类型不同

public class text1 {
    public static void main(String[] args) {
        show(1);
        show('a');
    }
    public static void show(int a){
        System.out.println(a);
    }
    public static void show(char a){
        System.out.println(a);
    }
//参数数据类型不同

public class text1 {
    public static void main(String[] args) {
        show('a',1);
        show(1,'a');
    }
    public static void show(int b,char a){
        System.out.println(b + " " + a);
    }
    public static void show(char a,int b){
        System.out.println(a + " " + b);
    }

3. 命令行传递参数

有时候你希望运行一个程序时候再传递给它信息。这要靠传递命令行参数给main（）函数实现。

public class test2{
      public static void main(String args[]){
          
          //args.length 数组长度
          for(int i=0; i<args.length;i++){ // length是数组的一个属性  
              System.out.println("args["+i+"]:"+args[i]); // 打印出数组的每个元素
          }
      }
 }

4.可变参数

基本概念：java允许将同一个类中多个同名，同功能但参数个数不同的方法封装成一个方法。就可以通过可变参数实现。

访问修饰符返回类型方法名（数据类型...形参名）{}

传入的多个参数会被以数组的形式传入，也可以直接传入数组。

可变参数可以和普通参数一同传入，但是要确定可变参数放在最后。

public int insum(double add,int... sum){
}

public class kebiancan{
	public static void main(String args[]){
		Sum sum = new Sum();
		//调用该方法，输入多个参数
		System.out.print(sum.insum(4,5,6));
	}
}
class Sum{
	//定义可变参数的方法，写一个求和方法
	public int insum(int... sum){
		int s = 0;
		for(int i = 0;i<sum.length;i++){
			s += sum[i];
		}
		return s;	
	}
}

5.递归

递归简单来说就是，自己调用自己。递归包含了一种隐式循环，会重复执行某段代码。

实际上，递归有两个显著的特征,终止条件和自身调用:

终止条件：递归必须有一个终止的条件，即不能无限循环地调用本身。

自身调用：原问题可以分解为子问题，子问题和原问题的求解方法是一致的，即都是调用自身的同一个函数。

public int sum(int n) {
    if (n <= 1) {
        return 1;
    } 
    return sum(n - 1) + n; 
}