JavaSE学习笔记(总)

最新推荐文章于 2023-12-05 19:42:30 发布

一只勤劳的小鸡

最新推荐文章于 2023-12-05 19:42:30 发布

阅读量98

点赞数

分类专栏： Java笔记

本文链接：https://blog.csdn.net/qq_26144863/article/details/108814312

版权

Java笔记专栏收录该内容

4 篇文章 0 订阅

订阅专栏

JAVA基础知识总结

第一章语言特点

简单
面向对象
分布式
健壮性
安全
体系结构中立
可移植
解释型
较高性能
多线程
动态性（在程序运行时可以添加方法和实例变量）

要点：JAVA程序执行是将

源代码（.java文件）–>通过JAVA编译器编译–> .class文件 -->通过解释器解释运行

先编译再解释，数据大小和运算格式固定，这些也奠定了多平台、强移植的基础。

第二章 JAVA开发环境

开发体系

java语法基础
运行java的虚拟机（JVM）
java API类库
javac（编译器）等辅助工具

1、2、3、4合称JDK （Java Development Kit）：java编程最小环境

2、3合称JRE（Java Runtime Environment）：java运行最小环境

版本（edition）

java SE (Standard Edition )：基础功能，桌面级应用以及简单服务器。
java EE (Enterprise Edition）：企业级服务器。
java ME (Micro Edition):移动端。

EE、ME都是以SE为基础。

第三章基础语法

1、注释

“ // ”
“ /* （注释内容）*/ ”
“ /* （注释内容）**/ ” 自动生成文档

2、数据类型

共四种，数字书写时可以加下划线如 999_9 编译器仍会按照 9999编译。

数字所占内存在任何平台都相同。

整型

int （正负20亿）、数字表示方法：

short（正负3.2万）、

long（九百亿亿）、后缀L（l）如10000000000L 即为long长整型

byte（-128~127）前缀 0b （0B）就可以写二进制数如 0b1001 就是十进制9

此外

前缀0x（0X）十六进制

前缀单个0 八进制
浮点型

float（浮点）、double（双精度浮点型）

NaN（不是一个数字）

判断一个值是否是一个数用Double.isNaN方法返回布尔值

如：if (x = Double.NaN) 。。。
字符型

char类型及单个Unicode字符。

char x = ‘A’;

或者直接用Unicode表示，一个Unicode编码是char类型，可能占用一个char类型的值也可能是两个。

Unicode编码会在代码编译前就被被转义

public static void main(String**\u005B\u00SD** args)是合法的，\u005B \u00SD分别表示[、]，在编译前就会被转义为[]。
布尔类型（Boolean）

boolean x = false;

布尔值有且只有 true和false两个，不能用数字代替。

3、变量、常量

变量声明、定义。

在Java中不区分变量的声明与定义，二者可以同时进行。

double x = 1.0; // 声明并定义


1. 声明变量最好逐行进行

 ```java
 int x, y; // 可以这样
 // 为了可读性，最好这样。
 int x;
 int y;

变量开头不允许是数字，变量名中不能有空格。

常量

final 关键字定义常量。
```
public class Constants
{
    public static void main(String[] args)
    {
        final double PI = 3.14;
    }
}
```
1. 常量一般大写
2. 定义于main方法外。
3. 同一类方法可以使用
4. 若被声明为public，则其它类也能使用。

4、运算

数学函数与数学常量（Math类）

Math.sqrt(x); // x的平方根
Math.pow(x, y); // x的y平方
// 常量
Math.PI;
Math.E;
import  static java.lang.Math.*;// 直接引用

数值类型转换

当多个数进行运算时，运算优先级

double>float>long>int

优先转换为高级别类型

强制类型转换

double x = 9.99;
int y = (int)x; // x=9,会直接截断

Math.round方法四舍五入返回为long类型

int z = (int)Math.round(x);// 用（int）强制将long型转换为int （可能造成数据丢失）

运算符

结合赋值

x += 1 等价于 x = x + 1

注意：
1. 如果得到的值与左侧类型不同，会强制类型转换为左侧。
2. 右结合， x += y += z等价于 x += (y += z) 最好不要这样做！

增值符 ++ 、–

n++；//先用后加
++n;// 先加后用

逻辑判断符

1、

==、!=、<、>、<=、>=…与c相同

也支持三元操作符号?:

condition ?expression: expression

若条件为真，表达式返回第一个expression，否则第二个
```
int x = 1;
int y = 2;
int n = x > y ? x : y;// 判断x是否大于y，若是则n = 1否则为 2；也可以是
int n = x > y ? 6 : 9;//若是则n等于第一个值，否则为第二个值
```
2、

关系判断符：&&（且）||（或）

二者遵循“短路”原则，例如 A & B ,如果A为false，则不再判断B，直接返回false。

注意 &&的运算优先级大于||
位运算符（TODO）
枚举型

个人认为是自定义变量类型，及其变量取值

如下为，变量类型是Size（类比int之类的类型），取值只有三个（而int是正负二十亿整数）
```
enum Size { X,XX,XXL };
//引用
Size x = Size.X
```

5、字符串

（仅基础概念，String类将单列学习）

1、Java字符串就是Unicode字符序列。

2、对字符串相关处理由 String这个类来处理。

3、源字符串不可改变，后续操作是构建新字符串。

4、字符串长度

String s= “” 也是s一个字符串，长度为0，里面就是什么也没有，空串也可以用Null填充

String s= “Null”，长度为1。

Java 字符串由char值序列组成，由于可能会有两个char值（代码块）对应一个Unicode值（码点）。实际长度是char值数。

⑪ is the set of octonions ⑪是由两个char值（代码块）标记的Unicode值（码点）

用codePoints方法，可以使码点与整数对应。

6、输入、输出

（仅基础概念，Scanner、PrintWriter类将单列学习）

标准输出流（控制台）

对于字符串 System.out.println()
想要读取信息进入程序，则需要用到Scanner类、

文件输入

Scanner in = new Scanner(Paths.get("flle.xxx"), "UTF-8");

Scanner(路径, 编码)

文件输出

PrintWriter out = new PrintWriter("file.xxx", "UTF-8");

7、控制流程

与c基本一样

条件执行

if (condition) {statement…}

if (condition) {statement…} else {statement…}
条件循环
1. while ( condition ) {statement…}
2. do {statement…} while (condition); 注意最后一个分号！！！
3. continue可以跳过循环。

for循环

for (int i = 1; i < 10 ; i++)
{statement...}

for (value : collection)
{statement...}

switch

switch(choice)
{
    case 1:
        statement...
        break;
    ...
    default:
        statement...
        break;
}

8、数组

（仅基础概念，Arrays类将单列学习）

数组是储存同一类型值的集合

声明数组
```
int[] a;
```
声明了名字为a，类型都为int 的数组。int与[ ]之间没有空格！

初始化、匿名数组

int[] a = new int[n]// 创建名为a，储存n个int类型值的数组。
int[] a = {1, 2}//简化赋值
new int[] = {1, 2}//匿名数组
int[] a;
a = new int[]{1, 2, 3}

数字数组初始化值均为0
Boolean数组初始化值为false

对象数组初始化为null

String[] names = new String[10]//创建包含十个“字符串”类型的数组每个字符串值为null

数组改值

int[] a = {1, 2};
a[1] = 3;//从0 开始
// a 变为{1 ,3}

数组拷贝、排序方法
1. 拷贝
```
int[] a = {1, 2};
int[] b;
b = Arrays.copyOF(a ,a.length)//第二个参数是新数组的长度。
```
如果数组是数字，多余长度为0

是字符串，多余为null

是Boolean，多余是false。
1. 排序
  
  Arrays.sort()

命令行参数

public class Message
{
	public static void main(String[] args) 
    {
       for (int i = 1; i < args.length; i ++)
		System.out.print("第"+ i + "个参数是" + args[i]);
		System.out.println("!");
    }
}

在命令行输入

java Message I LOVE YOU

将打印第0个参数是 I 第1个参数是 LOVE 第2个参数是YOU

多维数组

int[][] array = 
{
    {4, 8, 6},
    {5, 2, 0},
    {3, 6, 9}
};
/*其中
array[0][0] = 4
array[1][0] = 5
array[1][1] = 2
...
*/

第四章类与对象

1、概念

类（构造对象的模板）

由类构造对象的过程叫做实例（instance）

类之间的主要关系有依赖、继承、聚合（关联）
封装（encapsulation）

将数据和行为装进一个“包”中。
对象

三个主要特性
1. 行为：可以完成的任务
2. 状态：施加操作后返回的结果
3. 标识：区分对象
对象中的数据叫做实例域，

操作类的过程叫做方法，

2、预定义类

构造器、对象和对象变量

构造器名字应该与类名相同。

用new+类构造器及构建了一个对象。
```
new Date();
```
对象变量：
```
Data birthday = new Date();
```
可以直接定义一个对象变量。
```
Data birthday ;// birthday不是一个对象，不能引用方法。
birthday = new Data();
```
更改器方法和访问器方法

对象进行访问器方法，访问器方法会产生一个新的对象（如String对象的一些更改字符串的方法）。

对象进行更改器方法，则原对象本身就会被更改。

import java.time.*;
/**
 @version 2020-9-16
 @author Tominochick
 */
public class CalendarTest{
    public static void main(String[] args) {
        LocalDate date = LocalDate.now();
        int month = date.getMonthValue();
        int today = date.getDayOfMonth();

        date = date.minusDays(today - 1);
        DayOfWeek weekday = date.getDayOfWeek();
        int value = weekday.getValue();

        System.out.println("周一 周二 周三 周四 周五 周六 周日");
        for (int i = 1; i < value; i++)
            System.out.print("    ");
        while (date.getMonthValue() == month){
            System.out.printf("%3d", date.getDayOfMonth());
            if (date.getDayOfMonth() == today){
                System.out.print("*");
            }
            else {
                System.out.print("  ");
            }
            date = date.plusDays(1);
            if (date.getDayOfWeek().getValue() == 1)
                System.out.println();
        }
        if (date.getDayOfWeek().getValue() != 1)
            System.out.println();
    }
}

3、自定义类

格式

class Classname()
{
    实例域；
    field1
    ...
    constructer
    构造器；
    ...
    method
    方法；
    ...
}

4、静态域与静态方法

static 修饰符

静态域

类中的某个实例域如果被static修饰，则每一个类中只有一个唯一的域。

如果一个类有100个对象，这100对象可以有100个实例域，但只有一个静态域，不属于任一对象，只属于类本身。

所有对象共享，也都能进行更改。

静态方法

与静态域相似，属于类，而不是属于具体对象。

第五章继承

extends 单继承 A只能继承一个B

implements 多继承 A 能继承 B、C等多个类

class 子类 extends 父类{}

class A implements B, C{}

super 使用父类的方法

this 使用自己的方法

final 使用final修饰类，这类不会被继承，成为“最终类”

第六章多态

多态：

同一方法对不同对象采用多种不同的行为方式；

一个对象的实际类型是确定的，但可以指向对象的引用的类型是多样的。

// Student extends Person
Student A = new Student();
Person A = new Student();
Object A = new Student();

对象变量A（引用类型）是多态的，可以是Person、Object

对象变量能使用的方法取决于其 引用类型和子类方法是否被重写。

例如：Person A = new Student();

如果父类Person定义了f()方法，其子类Student重写了f()方法，则A.f()实现的是子类Student里的f()方法。

如果父类Person定义了f()方法，其子类Student没有f()方法，则A.f()实现的是父类Person里的f()方法。

如果父类Person未定义f()方法，其子类Student有f()方法，则A.f()无法调用，需要强制类型转换。

1、方法重写

在具有继承关系的前提下，子类重写父类的方法。

方法名、参数列表必须相同。
修饰符范围扩大不能缩小 public > protected > default > private
异常范围可以缩小，不能扩大 ClassNotFoundException -->Exception(大)

2、类型转换

instanceof判断子夫关系

A instanceof B; A 是否为B 的子类，是，返回true，

A<=B

类型转换

// Student extends Person
Person A = new Student();
((student) A).f();

3、抽象类、接口

用abstract修饰类，起占位作用，类的方法由子类实现。

public abstract class Action
{
    public abstract void f1();// 含有抽象方法，则该类必须是抽象类
    public  void f2();// 抽象类中可有有普通方法
}

普通类

只有实现
抽象类

有实现，有规范（抽象方法）
接口

只有规范。实现规范和实现分离

public interface UserService
{
    //接口中的方法都是public abstract（默认 不用写）
    void f1(x);
    void f2(y);
    ...
}

接口需要有实现类，必须实现接口中的所有方法。

实现类命名以impl结尾

public class UserServiceImpl implements Userservice 
{
    @override
    void f1(x);
    @override
    void f2(y);
    ...
}

implements后可以有多个接口

第七章异常

try、 catch、 finally、 throw、 throws

try
{
	//异常监视区
}
catch(Throwable x)// 第一个参数是异常类型， 第二个参数是异常变量
{
	//处理区
}
// 可catch多个异常范围最小的应该最先捕获 Throwable > Execption > IOException...
finally
{
    //善后区，无论是否有异常，都会执行。
}

在函数中抛出异常

public void f()
{
    throw new Expection();
}

如果在异常出现的类中无法处理此异常，可以在类层面上抛出异常

public class person throws IOExecption, RuntimeExecption
{
    ...
}

一只勤劳的小鸡

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JavaSE学习笔记(总)

JAVA基础知识总结文章目录第一章语言特点第二章 JAVA开发环境开发体系版本（edition）第三章基础语法1、注释2、数据类型3、变量、常量4、运算数学函数与数学常量（Math类）数值类型转换运算符5、字符串6、输入、输出7、控制流程8、数组第四章类与对象1、概念2、预定义类3、自定义类4、静态域与静态方法第五章继承第六章多态1、方法重写2、类型转换3、抽象类、接口第七章异常第一章语言特点简单面向对象分布式健壮性安全体系结构中立可移植解释型较高性能多线程动
复制链接

扫一扫