Java基础笔记

刘家奕_

已于 2024-01-13 01:13:52 修改

阅读量351

点赞数 1

文章标签： java 笔记开发语言

于 2023-11-16 17:53:05 首次发布

本文链接：https://blog.csdn.net/m0_62387059/article/details/134447173

版权

1.数据类型在java语言中包括两种:
第一种:基本数据类型
基本数据类型又可以划分为4大类8小种:
第一类:整数型
byte , short,int, long(没有小数的）

第二类:浮点型
float,aouble(带有小数的）

第三类:布尔型
boolean:只有两个值true和false，true表示真，false表示假

第四类:字符型
char: java中规定字符型字面量必须使用单引号括起来，属于文字。
8小种:
byte , short, int , long，float,double
boolean
char
第二种:引用数据类型
字符串型string属于引用数据类型-
string字符串不属于基本数据类型范畴
java中除了基本数据类型之外，剩下的都是引用数据类型。

关于计算机存储单位?
计算机只能识别二进制-( 1001101100 . ..)

1字节=8bit (8比特）--> 1byte = 8bit

1bit就是一个1或0.

1字节 = 1byte = 1B = 8位；
1KB = 1024B;
1MB = 1024KB;
1GB = 1024MB

基本数据类型所占字节数

2.转义字符

3.整数型

3.1整数型的4种编写方式

public class Main {
    public static void main(String[] args) {
        //十进制
        int a = 10;
        System.out.println(a);
        //八进制
        int b = 010;
        System.out.println(b);
        //十六进制
        int c = 0x10;
        System.out.println(c);
        //二进制
        int d = 0b10;
        System.out.println(d);
    }
}

3.2在java中有一条非常重要的结论:

在任何情况下，整数型的"字面量/数据"默认被当做int类型处理。(记住就行)如果希望该"整数型字面量"被当做long类型来处理，需要在"字面量"后面添加L/l建议使用大写L，因为小写字母l和1傻傻分不清-

3.3易错代码

下面给出一个易错代码：

编译器会不会报错呢？有人说y 是 long 类型的不会报错，--------这是错的，看上面加粗的字体。

这样就对了

下面也是错的

long l = 100L;

int x = l;

大容量转换成小容量,需要进行强制类型转换强制类型转换，如下

long l = 100L;

int x =（int）l;

需要加“强制类型转换符”，加上强制类型转换符之后编译通过了,但是运行阶段可能损失精度。

所以强制类型转换谨慎使用,因为损失精度之后可能损失很严重。

3.4强制类型转换

补充：补码，原码，反码

1. 原码

原码就是符号位加上真值的绝对值，即用第一位表示符号，其余位表示值。比如：如果是8位二进制：

[+1]原= 0000 0001

[-1]原= 1000 0001

第一位是符号位，因为第一位是符号位，所以8位二进制数的取值范围就是：（即第一位不表示值，只表示正负。）

[1111 1111 , 0111 1111]

即

[-127 , 127]

原码是人脑最容易理解和计算的表示方式。

2. 反码

反码的表示方法是：

正数的反码是其本身；

负数的反码是在其原码的基础上，符号位不变，其余各个位取反。

[+1] = [0000 0001]原= [0000 0001]反

[-1] = [1000 0001]原= [1111 1110]反

可见如果一个反码表示的是负数，人脑无法直观的看出来它的数值。通常要将其转换成原码再计算。

3. 补码

补码的表示方法是：

正数的补码就是其本身；

负数的补码是在其原码的基础上，符号位不变，其余各位取反，最后+1。(也即在反码的基础上+1)

[+1] = [0000 0001]原= [0000 0001]反= [0000 0001]补

[-1] = [1000 0001]原= [1111 1110]反= [1111 1111]补

对于负数，补码表示方式也是人脑无法直观看出其数值的。通常也需要转换成原码再计算其数值。

4.小结论：

4.浮点型

float----4字节

double-----8字节

在java语言当中，所有的浮点型字面值【3.0】，默认被当做double类型来处理，要想该字面值当做float类型来处理,需要在字面值后面添加F/f

float就不像byte那样有 ‘特权’ 了
比如：

float f =5.1;

是报错的，因为默认是double，赋值给float为大转小，如何解决呢？

第一种是没有类型转换

float f = 5.1F

第二种是强转

float f = (float)5.1;

5.类型转换

6条重要结论

double d = 10/3;

答案是多少?

答案是3.0，为什么，因为10/3字面量默认int，已经算出3

double d = 10.0/3;

答案是3.333333

例子

eg.

将g转换成int，然后又将int类型的g转换成byte,最后byte类型的g和3运算，那么它的运算结果类型就是int，所以int赋值给byte就出现了精度损失问题

6.运算符

6.1算数运算符

6.2关系运算符

6.3逻辑运算符

6.4赋值类运算符

x=x+5;

x+=5;

不一样，

6.5字符串连接运算符

+号

x + y -------------如果x和y都是数字的话，就是加法运算

如果x和y有一个为String类型的话，就相当于字符串连接

6.6三元运算符

易错

public class Main {
    public static void main(String[] args) {
        char c = true ? "1":'2';
        System.out.println(c);
    }

}

双引号（" "）：
- 双引号用于表示字符串（String），是一个字符序列。
- 字符串是不可变的，一旦创建后，其内容不能被修改。
- 用双引号括起来的内容可以包含任意字符，包括字母、数字、符号、空格等。

7.接受用户键盘输入

接受int

public class Main {
    public static void main(String[] args) {
        java.util.Scanner s = new java.util.Scanner(System.in);
        int b = s.nextInt();
        System.out.println(b);
    }

}

接受String

public class Main {
    public static void main(String[] args) {
        java.util.Scanner s = new java.util.Scanner(System.in);
        String b = s.next();
        System.out.println(b);
    }

}

如果不符合类型的话会报错

第二种写法：（idea会自动导包）

public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        String b = s.next();
        System.out.println(b);
    }

}

8.控制语句的分类

分为3大类

选择语句（分支语句） if，switch

循环语句 for while do while

转向语句 break continue

break模式详解

break跳出几层循环，是一层还是全部？_c# break跳出几层循环_刘家奕_的博客-CSDN博客

public class 和class的区别

一个java文件中可以定义多个class
一个class编译之后会生成1个class字节码文件，2个class编译之后会生成2个class文件

任何一个class中都可以编写main方法，每一个main方法都是一个入口
public的类可以没有
public的类如果有的话，只能有1个，并且public的类名要求和文件名一致。
class A{
main () { }
}
java A
class B{
main() { }
}
java B... .

final关键字

final修饰的实例变量，系统不负责赋默认值，要求程序员必须手动赋值。

这个手动赋值，在变量后面赋值可以，在构造方法中赋值也可以。

（1）变量后面赋值错误示范：

正确示范：

public class test2 {
final int a=0;
}

（2）构造方法中赋值

public class test2 {
final int a;
public test2(){
this.a=2;
}
}

final总结：

抽象类：

（1）abstract和final不能同时使用,这两个关键字是对立的；

（2）抽象类的子类可以是抽象类；

（3）抽象类虽然不可以实例化，但是可以有构造方法提供子类使用

（4）有抽象类就有抽象方法，抽象方法是什么呢？

抽象方法是没有实现的方法，没有方法体

如：

（5）抽象类里不一定有抽象方法，但是抽象方法一定在抽象类里面；

非抽象类继承抽象类

非抽象类继承抽象类，必须重写抽象类中的抽象方法；

abstract class test2 {
public abstract int T();
}
class test3 extends test2{

}

改正 test3

class test3 extends test2{
public int T(){
return 0;
};
}

如果抽象类继承抽象类，可以不用重写；

abstract class test2 {
public abstract int T();
}
abstract class test3 extends test2{

}

编译通过；

接口

接口是完全抽象的，而抽象类是半抽象的；

接口是特殊的抽象类

定义接口

interface B{
.........
}

接口可以继承

interface B{

}
interface C extends B{

}

一个接口可以继承多个接口

interface B{

}
interface C extends B{

}
interface D extends B,C{

}

接口中只有两个部分；

一个是常量一个是抽象方法（不能有主体）

均可省略public abstract

interface B{
   int a=0;
   void ok();
}

那么接口该如何去运用呢？

我们用类去实现它

因为接口也是抽象类，并且实现接口和继承类差不多所以我们要遵循类的基础，尤其是抽象类的基础的规则。

interface B{
int a=0;
void sum();
}

class C implements B{
public void sum(){
。。。。。。
}
}

那么一个类可不可以实现多个接口呢？

答案是可以的，但是要实现接口里的所有抽象方法。

继承和实现同时出现的话怎么写？

extends在去前

implement在后

抽象类和接口的对比总结

*接口是完全抽象的，而抽象类是半抽象的；

*接口只有常量和抽象方法，没有构造函数，而抽象类有构造函数；

*接口可以多继承，一个接口可以同时继承多个接口，而一个抽象类只能继承一个抽象类；

*接口的使用还是比抽象类多