学习笔记(11):Java小白修炼手册-一句话在Java中如何表达？快学Java字符串

立即学习:https://edu.csdn.net/course/play/27274/361060?utm_source=blogtoedu

1 

JDK Java语言的开发包（开发使用）
JRE Java的运行环境（运行生产使用）
JVM  Java的虚拟机
JavaSE（标准版 是基础）  javaME（微型版 是核心）  javaEE（企业版）
   Eclipse 跨平台开源集成开发环境 最初用来java语言开发

2   java语言的特点

简单、高效
面向对象（由类产生对象 不支持多重继承）
！跨平台（生成字节码不依赖任何硬件和操作系统平台  通过JVM实现跨平台的特性）
  源代码.java通过javac编译生成字节码.class 通过JVM虚拟机（安装在操作系统中）实现跨平台特性。

  一次编译，到处运行。

  Java跨平台，Java虚拟机不跨平台。

交互式特性
多线程机制
！动态的内存管理
  Java自动回收内存（机制：轮询机制）

  ！Java垃圾回收器GC（Garbage Collectioin）

安全性

3   搭建java开发环境

 

4    第一个java程序

    ①编写java程序

区分大小写
命名规范
原文件名和类文件名相同
主方法和入口
  ② 创建java文本文件（.java）→编写程序→

public class HelloWorld{
//class
 
public static void main（String[] args）{  
//method
System.out.println("HelloWorld")；
                }
}
 
→cmd（HelloWorld.java）→③执行java程序java类不带.class（HelloWorld）

注释：   1、public 关键字 公共的类  后面要有一个空格

              2、class 关键字 类  后面要有一个空格 

              3、HelloWorld 类名称 命名规范（驼峰命名法）

              4、{}配对 类体 class body

              5、public 关键字 公共方法 

              6、static 静态方法 可以直接访问 不需要实例化 

              7、void 方法的返回值为空

              8、main 主方法 入口方法 程序从这个方法进入并开始执行

               9、（String[] args）main方法的参数 类型是字符串数组类型

              10、{}方法体 method body

              11、System 类型里面的一个类 JDK 自带的一个类

              12、out 静态变量

              13、printIn 方法 out变量里的一个方法 输出到控制台 In 换行输出

              14、“HelloWorld！” 字符串参数 输出的内容是它

              15、;表示语句的结尾

 

  5    开发工具Eclipse

ctrl+/ 注释

alt+/代码导入

ctrl+1 提示

 

  6    Java核心技术

程序=输入+处理+输出
变量是给保存在内存中的数据起个名字，方便后续操作
变量的三要素：类型 名称 取值
变量分为：局部变量、实例变量和类变量
标识符就是给类、变量、方法、接口起的名字
命名规则：1、标识符应以字母 美元符$ 或者下划线_开始

                  2、首字符之后可以是任何字符的组合

                  3、关键字不能用作标识符

                  4、标识符区分大小写

类：是一个模板，是抽象的，描述一类对象的行为和状态；

是客观对象在人脑中的主观反映。

同一类型事物的共性抽象。

是封装对象属性和行为的载体。

由两部分构成：变量的声明；方法的定义。

this：区分成员变量和方法的局部变量。

this（）：调用本类的其他构造方法。

对象：是类的一个实例。

是具体的，客观存在的。

任何一个对象都有属性和方法的。

1）对象的特性：特征和行为
由类创建对象的过程叫实例化
方法：就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的
属性：每个对象都有独特的属性（实例变量），对象的状态是由属性值决定的

  7    java数据类型 

创建变量时，要申请内存空间
系统根据变量的数据类型，来分配空间大小
八种基本类型  六种数字类型（四个整数型 两个浮点型）一种字符类型 一种布尔类型 

             基本类型             大小               取值范围

       1、     booleon       1字节8位         true fals

       2、      byte     1字节8位有符号整数      -128-+127         

       3、      short     2字节16位有符号整数

-32768-+32767

       4、         int      4字节32位有符号整数

-2147483648-+2147483647

       5、       long   8字节16位Unicode字符

-2 63次方-+2 63次方-1

       6、       char    2字节16位Univode

0-65535

       7、       float    4字节32位浮点数（float f=xxf）

       8 、      double   8字节64位浮点数

 

  8    java运算

算术运算 + - * / %
①a/b 整数除整数结果取整（除数不能为0）

②a/b整数除浮点结果为浮点

比较运算 ＞ ＞= ＜ ＜= == !=
逻辑运算 & | ！  && ||（短路与 短路或  如果前面的表达式可以确定结果，后面的表达式将不再计算）
赋值运算 将等号右边的结果赋值给左边
①简单赋值（右侧常量 变量 方法返回值等都可）

②复合赋值 自身运算

③自增自减（前缀式++i 先加1再使用；后缀式i++ 先使用再减1 ）

三元运算  e1？e2：e3

 

  9    分支语句（选择语句）

①if语句    if后必须是布尔值

②switch语句  表达式值必须为：byte int char short 

                        case必须是常量，不能有相同的值 

                         条件表达式：变量=布尔表达式？表达式1：表达式2等价于   if（布尔表达式） 变量=表达式1；else 变量=表达式

 

10  循环语句:用于解决需要重复运算的问题

必要因素：循环初始条件  循环条件  循环体  让循环趋向结束的语句

①while语句格式     while（循环条件）{循环体；}   先判断，后循环 

②do while语句格式    do{循环体；}while（循环条件）  先循环，后判断   循环体中有语句至少要执行一次使用do循环

③for循环 语句格式    for（表达式1；表达式2；表达式3）{循环体；}    表达式1为循环变量赋初值，表达式2用于控制何时退出循环，表达式3为循环变量的修改部分

1）最为灵活，适用范围最广

2）可以用于循环次数已确定的情况

3）也可用于循环次数不确定，但能给出循环结束条件的循环 

④循环的嵌套：

1）循环体内包含循环语句

2）多重循环在执行时，由里向外展开，先执行内层循环，再执行外层循环

3）break continue return可以用在循环语句中为循环提供附加控制

break：立即终止内层循环（用于循环或开关语句，跳出当前循环或开关循环）

continue：只结束当前迭代，将程序控制转移到循环的下一次迭代（用于循环语句，结束本次循环；在while和do while中直接跳转到条件表达式，而在for循环中直接跳转到表达式3）

return：返回到程序调用处，结束方法调用

 

11  方法

①函数=方法=模块化设计

②java中所有的方法都必须封装在类中，不能单独出现、使用

③参数传递以传值方式进行，实参传给形参

 

12  数组：复合引用数据类型（类型相同的有序数组集合，按一定顺序分配在内存中一片连续的区域）

①所有数据给定一个标识符 叫数组名

②数组中的每个元素叫数组元素

③元素类型可以是所有基本类型

1）数组声明格式：数据类型 数组名[  ] 或 数据类型[  ]数组名称

    数据类型可以是基本类型也可以是类型

①数组声明后在内存中不占空间，没有地址

②数组是复合数据类型，声明完以后默认值是null

③数组声明以后不能直接使用，必须对其初始化以后才可使用

2）一对数组的初始化

①对数组进行赋值

②分为静态初始化（整体赋值）：一次为数组中所有元素进行赋值    （指定了数组中所有元素；指定了数组长度）

    值得类型需和数组声明时类型匹配，或自动进行转换；

    一般用于一组无规律的已知数组；

          动态初始化：只为数组指定长度，在内存中申请空间

    只申请了空间；

    每个元素的值取数组数据类型的对应值（Boolean默认值是false；其他七种数据类型是0；char的默认值是编码为0的字符）

③引用数组元素  形式：数组名[下标]    下标从0开始

3）二维数组声明  声明格式：数据类型 数组名[  ]  或数据类型[  ] 数组名

                 初始化 ：静态 int temp[ ][ ]={ {1,2},{3,4} {5,6}}

                                动态 int temp[ ]；temp=new int[5][6];  或者 int temp[ ][ ]=new int[5][6];

                  引用： 引用方式：数组名[下标1] [下标2]

 

13  字符串：java提供string类来创建和操作字符串

字符串处理类

1）对象池：java对象的生命周期包括：对象的创建、对象的使用、对象的释放。

2）字符串常量（“”引起）就是一个字符串对象。

3）构造字符串对象：

  创建String对象常用的方法

String2=“xxx”；

String str4=new String（str3）；内容一样，但指向内容中不同的对象实体。

4)字符串处理操作的方法：获取字符长度，字符串相等判定，字符串比较，字符串连接，字符串查询，字符串替换，去除空格，取子串，大小写转换等处理操作

  调用格式：字符串变量名.方法名（）；

 

①直接赋值创建字符串

String name=“xxx”

②使用构造函数创建字符串

String name=new String（“xxx”）

③字符串连接

使用+号； System.out.printIn(name+name);

使用concat;

System.out.printIn(name.concat(“name”));

④字符串格式化

System msg=String.format（“name%s（字符），name%d（数字 整型），name%f（浮点型）...)

⑤字符串方法

String s=“xxx”；

Systen.out.printIn(s.charAt(0));   取某一字符

for (int i=0;ilength();i++){   长度

System.out.print(s.charAt(i)+" ");}  遍历字符串字符

System.out.print(s.substring(3,6));   取某一部分数组

System.out.print(s.trim())；  去掉两边的空格

！System.out.print(s.indexOf(‘ ’));   取字符串或某一位置的长度

⑥equals（）和equalslgnoreCase（）

boolean equals（String s）将参数字符串s的值与调用该方法的String值进行比较返回ture或false

⑦endsWith（）和startsWith（）

boolean endsWith（String s）判断调用该方法的String是否以指定的参数字符串结尾，返回ture或false

boolean startsWith（String s）判断调用该方法的String是否以指定的参数字符串开始，返回ture或false

⑧toLowerCase（）和toUpperCase（）

！String tolowerCase（）将调用该方法的String的所有大写字母转化成小写字母。

String toUpperCase（）将调用该方法的String的所有小写字母转化成大写字母。

⑨public String replace（char oldChar，char newChar）将当前字符串中出现的所有oldChar转换为newChar

⑩public itn compareTo（String strCompared）比较操作，相等时返回0，当前字符串（按字母比较）大于参数字符串时返回正整数，当前字符串小于参数字符串时返回负整数。

 

14 字符串处理类

①StringBuilder类和StringBuffer类（实体内存空间可以自动变化，便于存放变化的字符串）

②三个构造方法

StringBuffer（）用于创建一个空的StringBuffer对象。

StringBuffer（int length）指出了创建的对象字符串的长度。

StringBuffe（String str）用一个字符串初始化创建的对象。

③常用方法

append（）方法：将一个字符串添加到一个字符串缓冲区的后面，如果添加字符串的长度超过字符串缓冲区的容量，则字符串缓冲区自动将容量扩充；

insert（int offset，representation）方法，用于在指定的位置插入给定的量。

toString（）将字符串缓冲区转化为字符串

charAt（int index）取指定位置的字符

delete（int start，int end）方法用于删除从star~end之间的字符串

deleteCharAt（int index）方法用于删除位置index处的字符串

replace（int star，int end，String str）用字符串str替换star到end的位置

 

15 Object类（java程序中所有类的直接或间接类，也是类库中所有的父类）

①Object clone（）生成当前对象的一个拷贝。

②Boolean equals（Object object）比较两个对象是否相等

③Class getClass（）获取当前对象所属的类信息

④String toString（）用来返回当前对象本身的有关信息

⑤protected void finalize（）当垃圾收集器确定对象上没有其他引用时，调用对象上的垃圾收集器，Obiect上的此方法不执行任何特定行为，仅简单返回，其子类会覆盖此方法。

 

16 System类（系统功能类 提供标准输入输出）

17 Class类（封装了一个对象的描述）

18 Math类  （Math.abs（）；（绝对值））

19 Date类

20 Calendar类

 

21 java 面向对象

1）类的特点：封装性，继承性，多态性

2）类和对象

①实例变相→实例方法→由类产生对象的过程叫实例化，对象object=实例instance，

②一个类可以创建多个实例

3）类变量和类方法（静态变量和静态方法）

①特点：不需要实例化可以通过类名称来方法

4）构造方法

①this 是一个指代对象 当前对象是谁this值就是谁

 

22 java接口

1）定义接口：更好地实现程序的抽象过程

2）一个类可以实现多个接口

3）接口可继承

 

23 封装与类

1）封装：把对象的属性和操作结合为一个独立的整体，并尽可能隐藏对象的内部细节。

①setter（）方法：给成员变量赋值，设值方法不会返回任何值；将方法参数设为对应的实例变量的返回值。

②getter（）方法：获取成员变量的值，获取存储在对象中的实例变量的值，通过程序返回并发送出去，取值方法必须返回的值作为return的参数。

2）含义：

①把对象的全部属性和全部服务结合在一起，形成一个不可分割的独立单位。

②实现“信息隐蔽”，尽可能隐藏对象内部细节，对外界形成一个边界，只保留有限的外部接口与外界进行联系。

3）基本数据类型：字符型，数值型，布尔型。

     引用数据类型：数组，类，枚举类型，接口。

4）“抽象“”是面向对象设计环节中的重要环节。

5）面向过程程序设计：自顶而上，逐步求精。

6）面向对象设计：从设计类开始，然后向类中添加方法。

7）面向对象的思维方式：以对象为中心，分析对象的行为，状态，抽取出类的设计。

 

24  静态static：当在类中声明一个成员时，可以指定他是为一个类的各个对象各自拥有（实例成员），还是为一个类的所有共享对象（类范围的成员→称为静态成员，以关键字static声明）。

1）static数据成员：为类的对象所共享的数据。

2）static方法：不必创建对象直接使用类名即可调用。

3）static修饰符：主方法main具有修饰符，使用static修饰的方法可以在main中调用。

4）类名.静态成员

4）static成员：①在static方法中不允许使用非static成员。

②在非static方法中既可以使用非static成员，也可以使用static成员

5）静态变量：（用static修饰，也叫类变量）所有实例共享一块内存空间，通常使用类名访问；

实例变量：未用static修饰，每个实例有自己的内存空间，必须使用实例名来访问。

6）f（）可以访问静态的属性和静态的方法。

g（）不能访问非静态属性x，也不能访问this关键字。

7）实例变量初始化：声明时初始化；使用初始化块；使用构造方法初始化。

 

25  包（文件夹）——类相当于文件夹下的文件

1）作用：

①功能相关的类和接口放到一个包中。

②实现命名管理机制，同名的类可以放在不同的包中。

③实现对类的访问控制。

 

26  类的继承：继承是根据现有类创建新的类的机制，由继承而得到的新类称为子类或派生类，被继承的类分为父类或基类。

1）java是单继承，只有一个父类。

2）Object是所有类的祖先。

3）代码复用的手段：

①“is-a”关系：类之间继承的关系。

②："has-a"关系：类之间是组合的关系。

4）继承分类：

①单继承：一个子类最多只能有一个父类。

②多继承：一个子类可有两个以上的父类。

java类只支持单继承，而接口支持多继承。

5）子类定义的一般格式：

【类修饰符】class 子类名 extends 父类名{

成员变量定义；

成员方法定义；}

①子类名需符合命名规则

②extends是关键字

③父类可以是自定义的类也可以是系统类库的类。

④子类可以添加新的成员变量和成员方法，也可以隐藏或覆盖父类成员方法。

⑤java只支持单继承。

⑥类之间的继承具有传递性。

6）继承关系中构造方法的作用：

①子类可以在自己构造方法中使用关键字super来调用父类的构造方法，super调用语句必须是子类构造方法中第一个可执行语句。

②子类在自己定义构造方法中如果没有用super明确调用父类的构造方法，在创建对象时，首先自动执行父类的五参构造方法，再执行自己定义的构造方法。

 

27  重写父类方法

1）Object类：java中所有类的父类，定义和实现了java系统下所有类的共同行为。

2）方法的重写遵循“两同两小一大”的规则：

“两同”：方法名称相同，形参列表相同。

“两小”：子类方法返回值类型≤父类方法返回值类型

             子类方法抛出的异常型≤父类方法抛出的异常型

 “一大”：子类方法的访问权限≥父类方法的访问权限

3）子类中重写的方法应与父类中的被覆盖的方法有完全相同的方法名称，参数列表，返回值类型，但执行的方法体不同。

4）不能重写父类final方法

 

28  子类对象的构造

1）调用次序子类构造方法再执行自己的任务之前，将显示地（super调用）或隐式地（调用父类默认地无参数构造法）调用其直接父类的构造方法。

2）super和this调用构造方法：子类不会继承父类的构造方法，但子类可以调用父类的继承方法

3）final修饰符：修饰类时，类不能被继承；修饰方法时，方法不能被重写；修饰变量时，变量只能被赋值一次。

 

29  多态性

1）多态是同一个行为具有多个不同表现形式或形态的能力。

2）多态就是同一个接口，使用不同的实例实行不同的操作。

3）多态的优点：

①消除类型之间的耦合关系。

②可替换性。

③可扩充性。

④接口性。

⑤灵活性。

⑥简化性。

4）三个必要条件：

①继承

②重写（不同类的同名方法，两个类之间是继承关系；子类对父类方法的重新定义；重写一定是伴随继承关系发生的，没有继承就没有重写）

    （重载：一个类中同名方法，参数类型不同或个数不等）

③父类引用指向子类对象

5）可分为类型多态和方法多态。方法多态又可细分为重载多态和重写多态。

6）对象转换：

①自动转换  upcasting 向上转换  （子类对象自动转换成父类对象，可将子类型的引用赋值给父类型的引用）

②强制转换 向下转换 使用（）运算符  （将父类对象强制转换为子类对象）

③instanceof运算的格式：  引用变量名  instanceof 类名  （引用变量确实是这个类或这个子类的对象为true否则为false）

7）多态性：静态多态和动态多态

①静态多态：编译时多态通过方法重载实现，本质是用一个方法名来命名一组方法，这一组方法在整个参数，参数类型或次序上有区别，编译时编译程序进行匹配，决定调用哪个方法。

②动态多态：运行时多态通过方法重写实现，是执行期间判断所引用对象的实际类型，根据实际类型调用其相应的方法。

 

30  抽象类：一个类中没有足够的信息来描绘一个具体对象，这个类就是抽象类 

  目的：被继承

最终类的目的是：不被继承

1）表示一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

2）在java语言中使用abstract class 来定义抽象类。

3）抽象方法和非抽象方法：抽象类不能用new关键字来构造对象。抽象类的子类可以重写父类的抽象方法（方法实现），也可以继承该抽象方法。

4）格式：

abstract class 类名称{

声明数据成员；

返回值的数据类型 方法名称（参数列表）{

定义普通的方法}

abstract 返回值的数据类型 方法名称（参数列表）

5)注意：抽象方法中的处理方式必须在子类中完全实现；

抽象类不能被实例化。

6）开闭原则：面向对象设计的一个最核心原则，对于扩展是开放的，对于修改是关闭的。

 

31  接口：是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。接口包含要实现的方法。

1）接口无法被实例化，但可以被实现。

2）接口类型可以声明变量，可以成为一个空指针，或是绑定在一个以此接口实现的对象。

3）接口是一种引用数据类型，以接口为类型的引用变量，其值指向一个实现该接口的类的对象。

4）接口是用来实现类间多重继承功能的结构。是一种特殊的抽象类，接口用来表明一个类必须作什么，而不是规定他去如何做（只定义不实现）因此接口常用来指定类的协议。

5）接口由常量和一组抽象方法组成。接口支持多重继承：一个类可以同时实现多个接口；一个接口可以同时继承多个接口

6）定义接口的格式： interface 接口名[extends 父接口名列表]{

                                        [public][final][static]类型  常量名=常量值；

                                        [public][abstract]返回类型 方法名（参数列表）；

}

7）实现接口就是实现接口定义的抽象方法，需要在类声明中用implements子句来实现接口

[public] class ClassName implements

InterfaceList{

         //类体定义

}

抽象类与接口的区别

 

32  Lanbda表达式：可以传递给方法的一段代码，可以是一个语句，也可以是一个代码块。

1）函数式接口是指仅包含一个抽象方法的接口，因此也称为单抽象方法接口。

2）每一个Lanbda表达式都对应一个函数式接口类型。可以将Lanbda表达式看作实现函数式接口的类的一个实例。

3）在java类库中有些接口只含有一个抽象方法。如Runnable接口，Comparable接口和Comparator等接口。

4）在定义函数式接口时可以给接口添加@Functionallnterface注释。如果接口定义多于一个抽象方法，编译器会报错。

5）语法：（参数1，参数2，...）>表达式

（参数1，参数2，...）>{/*代码块*/}

 

33  java异常体系

1）可分为可查的异常和不可查的异常（运行时错误和错误）

2）exception异常分为运行时异常和非运行时异常

3）处理异常机制：抛出异常，捕捉异常

4）java规定：当一个方法选择不捕捉可查异常时，他必须声明将抛出异常。（异常总是先被抛出，后被捕捉）

5）从方法中的抛出的任何异常都必须使用throws

6）捕捉异常通过try-catch语句或者try-catch-finally语句实现。

7）捕获异常：try catch finally

  ①匹配原则：抛出的异常对象属于catch子句的异常类，或者属于该异常类的子类，则认为生成的异常对象与catch块捕获的异常类型匹配。

②一旦某个catch捕获到匹配的异常类型，将进入异常处理代码，一经处理结束，就意味着整个try-catch语句结束。其他的catch子句不再有匹配和捕获异常类型的机会。

③无论是否捕获或处理异常，finally块里的语句都会被执行。

④当在try块或者catch块中遇到return语句时，finally语句块将会在方法返回之前被执行，（在finally语块中发生异常；在前面System.exit（）退出程序；程序所在的线程死亡；关闭CPU   finally块不会被执行）

8）throws抛出异常

9）自定义异常类

34  java输入输出流（intput/output）：程序与外部设备或其他计算机进行数据交换的过程

1）java用流的方式处理“I/O”，对应不同类型的I/O问题，会有相应的流对象提供解决方案。

2）java流的类层次结构：

①流的定义：流是在计算机输入输出操作中流动的数据系列。

(输出流是往存储介质或数据通道中写入数据，

输入流是从存储介质或数据通道中读取数据）

3）java支持文件I/O和流式I/O。流式IO分为输入流和输出流。

（二进制流称为字节流，文本流称为字符流）

 

4）流的特性：先进先出；顺序存储；只读或只写。

5）java流的处理类：

①面向字节的流：数据的处理是以字节为基本单位。

②面向字符的流：用于字符的数据的处理。

6）文件：File 用于管理文件系统中有关文件/文件夹的信息

                RandomAccessFile：用于区别输入/输出流的行为方式访问文件

7）RandomAccessFile的特点：以字节为单位进行文件内容的存取。

8)字节流：以八位的字节为读写单位

①字节流体系：以抽象类InputStream和OutputStream作为顶层向下包含了众多子类成员

9）FileputStream是一个简单的输入流类，直接继承于InpotStream类

10）字符流

 

35  

1)图形用户界面：程序通过GUI为用户提供交互式的图形化操作，接受用户的输入并向用户输出程序运行的结果。

2）AWT:java抽象窗口工具集。

3）Swing：在AWT基础上构建的一套新的图形界面系统。

4）组件：是一个以图形化方式显示在屏幕上并能与用户进行交互的对象。例如按钮，标签，单选/多选按钮，文本框等，组件通常被放在容器中。

5）容器：是Compinent的子类，所以说容器本身也是一个组件，具有组件的所有特性，同时又具有容纳基本组件和容器的功能，一个容器可以将多个容器和基本组件为一个整体。

6）AWT（抽象窗口工具包）的容器：容器分为容器类组件和非容器类组件两大类。

     

36

布局管理器

1、FlowLayout  流式布局：按照组件添加到容器中的次序顺序排放组件。

2、BorderLayout  边界布局：分为东西南北中五个布局。

3、GridLayout  网格布局：将容器分为等长等大的若干网格，每个网格放一个组件。

4、CardLayout  卡片布局：将容器中的多个组件看成一叠卡片，占据容器的整个区域。

 

37  事件处理

1、事件类型：表示与事件相关的具体类型

2、事件处理：

3、处理事件必须为节点注册事件处理器。

①使用控件提供的方便方法来注册事件处理器。

②使用Node类的addEventHandler（）方法。

38  线程状态与生命周期

1、线程由新new，就绪runnable，运行running，阻塞sleep，死亡daed这些状态构成，呈现其工作过程。

2、线程调度器：基于优先级的抢先式调度机制。