java中阶段详细笔记(没有之一！)

最新推荐文章于 2024-05-16 10:23:10 发布

CjShelby

最新推荐文章于 2024-05-16 10:23:10 发布

阅读量93

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_44717803/article/details/117970927

版权

java面向对象编程

1.面向对象编程的概念(理解):

1. 万物皆对象
1. 面向对象：
- 指以 (属性)或 (特征) 和 (行为) 的观点去分析现实生活中的事物

2. 面向对象编程：

指先以面向对象的思想进行分析，然后使用面向对象的编程语言进行表达的过程。

3. 类和对象的概念：

对象(具体客观的某一个)：
- 指现实生活中客观存在的实体，在 JAVA 语言中对象体现为内存空间中的一块存储区域
- 功能：
  - 对象的数据结构由定义它的类来决定
类(对多个对象的统称)：
- "分类" 的意思 , 是具有相同特征和行为的多个对象共性的抽象描述，在 JAVA 语言中体现为一种引用数据类型
  - 包含：
    - 1. 描述特征/属性，也就是成员变量
    - 1. 描述行为，也就是成员方法
- 功能：
  - 用于构建对象的模板

4. 类的定义(重点)：

格式：
- class 类名 {
  - 类体;
- }
注意：
- 通常情况下，当类名由多个单词组成时，要求每个单词首字母都要大写

5. 成员变量的定义(重点)：

格式：
- class 类名{
- 数据类型成员变量名 = 初始值;
  - 注意：
    - 通常可以省略不写，可由引用变量名. 成员变量名来赋值对应的数据信息。
- }
注意：
- 当成员变量由多个单词组成时，通常要求从第二个单词起每个单词的首字母大写

6. 对象的创建(重点):

格式：
- new 类名();
  - 例如： new Person();
  - 注意：
    - 这种写法没有接收他申请到的堆区里的信息地址的引用变量名，所以叫 "匿名对象"
注意:
- a. 当一个类定义完毕后，可使用 new 关键字来创建该类的对象，这个过程叫做类的实例化
- b. 创建对象的本质就是在内存空间的堆区申请一块存储区域，用于存放该对象独有特征信息

7. 引用的定义(重点):

基本概念:
- a. 使用引用数据类型定义的变量叫做引用型变量(引用变量)，简称 "引用"
功能：
- 用于记录对象在堆区中的内存地址信息，便于下次访问
格式(重点)：
- 类名引用变量名;
- 引用变量名.成员变量名;
例如：
- Person p = new Person(); // 类名引用变量名;
- p.name= "张飞";
- System.out.println(p.name);

8. 成员方法的定义(重中之重)：

1. 格式：
- class 类名{
- 返回值类型成员方法名(形参列表){
- 成员方法体;
- }
- }
- 例如：
  - class Person{
  - void show(){
  - System.out.println("没事就秀一下！");
  - }
  - }
注意：
- 当成员方法名由多个单词组成时，要求从第二个单词起每个单词的首字母大写
1. 返回值类型的详解：
- 1. 返回值：
  - 从方法体内返回到方法体外的数据内容
- 1. 返回值类型：
  - 指返回值的数据类型，可以是基本数据类型，也可以是引用数据类型
  - 例如：
    - 当返回的数据内容是66时，则返回值类型写 int 即可
- 1. return :
  - 在方法体中使用 return 关键字可以返回具体的数据内容并结束当前方法
  - 例如：
    - 当返回的数据内容时66时，则方法体中写 return 66; 即可
- 1. void:
  - 当该方法不需要返回任何数据类型时，则返回值类型写 void 即可
1. 形参列表：
- 1 .形式参数功能：
  - 用于将方法体外的数据内容带入到方法体内部
- 1. 形式列表：
  - 指多个形式参数组成的列表
- 1. 格式：
  - 数据类型形参变量名1 , 数据类型形参变量名2 , ...
  - 例如：
    - 当带入的数据内容是 "hello" 时，则形参列表写 String s 即可
    - 当带入的数据内容是66 和 "hello " 时 , 则形参列表写 int i ,String s 即可
    - 若该方法不需要带入任何数据内容时，则形参列表位置啥也不写即可
1. 方法体详解：
- 成员方法体功能:
  - 用于编写描述该方法功能的语句块
- 实现：
  - 实现代码的重用，简化代码
- 注意:
  - 成员变量和成员方法都属于类内部的成员，因次可以直接访问成员变量不需要再加引用 . 的前缀
  - 例如：
    - int y;// 横坐标
    - int x;// 纵坐标
    - // 自定以一个成员方法实现所有成员变量的打印
    - public void write(){
    - // 3.将横纵坐标修改为3 和 5 后再次打印
    - System.out.println("横坐标:"+y+" ,纵坐标: "+x);
    - }
1. 方法的调用：
- 格式：
  - 引用变量名 . 成员方法名(实参列表);
- 实际参数列表功能:
  - 用于对形式参数进行初始化操作，因此参数的个数，类型以及顺序都要完全一致
- 实际参数：
  - 可以传递直接量，变量，表达式，方法的调用等
5.可变长参数:
- 格式：
  - 返回值类型方法名(参数的类型... 参数名)
- 注意:
  - 方法参数部分指定类型的参数个数是可以改变的, 也就是 0~n个
  - 一个方法的形参列表中最多只能声明一个可变长形参,并且需要放到参数列表的末尾
  - 例如：
    - public void showArgument(String ... args){ // 定义可变长参数
    - for (int i = 0; i < args.length; i++) { // 使用for循环挨个将里边的数值打印
    - System.out.println("第"+(i+1)+"个参数为: "+args[i]);
    - }
    - }
  - 开始调用：
    - p.showArgument("参数1");
    - p.showArgument("参数1","参数2");
1. 方法的传参过程:
- int max(int ia, int ib){... ... ... } int a = 5; int b = 6; int res = m.max(a,b);
  - 1. 为main方法中的变量 a , b, res 分配空间并初始化
  - 1. 调用 max 方法，为 max 方法的形参变量 ia , ib 分配空间
  - 1. 将实参变量的数值赋值到形参变量的内存空间中
  - 1. max 方法运行完毕后返回，形参变量空间释放
  - 1. main 方法中的 res 变量得到 max 方法的返回值
  - 1. main 方法结束后释放相关变量的内存空间
1. 参数传递的注意事项：
- 1. 基本数据类型的变量作为方法的参数传递时，形参变量数值的改变通常不会影响到实参变量的数值，因为两个变量有各自独立的内存空间
  - 例如：
    - // 定义成员变量
    - int ia;
    - int ib;
    - // 1.创建成员方法
    - public void show1(int ia ,int ib){
    - ia = 200;
    - ib = 300;
    - System.out.println("ia的值为: "+ ia+"ib的值为: "+ib); // 200， 300
    - }
    - public static void main(String[] args) {
    - // 编程实现参数的传递并在方法里修改实参的数值信息
    - // 2. 定义类的引用变量名并创建对象
    - ArgumentTest at = new ArgumentTest();
    - at.show1(10,20);
    - at.ia = 20;
    - at.ib = 30;
    - System.out.println("ia的值为: "+ at.ia+"ib的值为: "+at.ib); // 20， 30
- 1. 引用数据类型的变量作为方法的参数传递时，形参变量指向内容的改变会影响到实参变量指向内容的数值，因为两个变量指向同一块内存空间
  - 例如：
    - public void show2(int[] arr2){
    - int[0] arr2 =200;
    - System.out.println("在show2方法中的arr2[0]: "+arr2[0]); // 200
    - }
    - public static void main(String[] args){
    - Argument at = new Argument();
    - int[] arr1 = new int[]{20,30};
    - at.show2(arr1);
    - System.out.println("在main方法汇总的arr1[0]: "+ arr2[0]);// 200
    - }
- 1. 当引用数据类型的变量作为方法的参数传递时，若形参变量改变指向后再改变指定的内容，则通常不会影响到实参变量指向内容的改变，因为两个变量指向不同的内存空间
  - 例如:
    - public void show2(int[] arr2){
    - int[] arr2 = new int[2]; // 此时创建了新的数组内存空间，此数组已经和arr1再无关系。
    - int[0] arr2 =200;
    - System.out.println("在show2方法中的arr2[0]: "+arr2[0]); // 200
    - }
    - public static void main(String[] args){
    - Argument at = new Argument();
    - int[] arr1 = new int[]{20,30};
    - at.show2(arr1);
    - System.out.println("在main方法汇总的arr1[0]: "+ arr2[0]);// 20
    - }
1. 内存结构之栈区：
- 1. 栈：
  - 功能：
    - 存放程序运行过程当中所有的局部变量，一个运行的java程序从开始到结束会有多次方法的调用
- 1. JVM(虚拟机) 会为每一个方法的调用在栈中分配一个对应的空间，这个空间称为该方法的栈帧。一个栈帧对应一个正在调用中的方法，栈帧中存储了该方法的参数，局部变量等数据
  - 注意：
    - 当某一个方法调用完成后，其对应的栈帧将被清除
- 1. 参数：
  - 1. 分为形参和实参
  - 1. 定义方法时的参数叫形参
  - 1. 调用方法时传递的参数叫实参
  - 1. 调用方法时采用值传递把实参传递给形参，方法内部其实是在使用形参
  - 1. 值传递：
    - 1. 就是当参数是基本数据类型时，传递参数的值，比如传递 i = 10 ,真实传参时，把10 赋值给了形参。
    - 1. 当参数时对象时，传递的是对象的值，也就是把对象的地址赋值给形参

9. 构造方法的概念和使用(重中之重)：

1. 格式：
- class 类名{
- 类名(形参列表){
- 构造方法体;
- }
- }
- 例如：
  - class Person{
  - Person(){ // Person类中的构造方法
  - }
  - }
1. 特点：
- 构造方法名与类名完全相同并且没有返回值类型，连void都不许有
1. 默认构造方法：
- 当一个类中没有定义任何构造方法时，编译器会自动添加一个无参空构造构造方法，叫默认/缺省构造方法
- 例如：
  - Person(){}
- 注意：
  - 若类中出现了构造方法，则编译器不再提供任何形式的构造方法
1. 构造方法的作用：
- 使用new关键字创建对象时会自动调用构造方法实现成员变量初始化工作

10. 方法重载的概念(重点)：

1. 若方法名称相同，参数列表不同，这样的方法之间构成重载关系(Overload)
- 注意：
  - 1. 重载与参数变量名无关:
    - 例如:
      - public void show(int i,double d){
      - System.out.println("i + d = "+i+d);
      - }
      - public void show(int a,double b){ // 错误写法，重载与参数变量名无关
      - System.out.println("i + d = "+a+db;
      - }
  - 1. 重载与返回值无关(但建议返回值类型最好相同):
    - 例如：
      - public void show(int i,double d){
      - System.out.println("i + d = "+i+d);
      - }
      - public int show(int i , double d){ // 错误写法，重载与返回值无关
      - System.out.println("i + d = "+i+d");
      - }
1. 重载的体现形式：
- 方法重载的主要形式体现在:
  - 1. 参数的个数不同
  - 1. 参数的类型不同
  - 1. 参数的顺序不同
1. 判断方法能否构成重载的核心：
- 调用方法时能否加以区分
1. 重载的实际意义:
- 在于调用者只需要记住方法名就可以调用各种不同的版本，来实现各种不同规格的功能

11. this的基本概念(掌握原理):

1. 若在构造方法中出现了this关键字，则代表当前正在构造的对象
1. 若在成员方法中出现了this关键字，则代表当前正在调用的对象
- 注意：
  - this关键字本质上就是当前类类型的引用变量
1. this关键字的工作原理：
- this.相当于汉语中的"我的"
- 1. 在成员方法中不用调用用类名调用成员变量的原因：
  - 成员方的代码体中隐含着this关键字，也就是类类型的引用变量(this)
    - 例如：
      - String name ;
      - int age ;
      - public void show(){ // 成员方法
      - System.out.println("我是"+thsi.name+"今年"+this.age);// 隐含着this关键字，也可以在成员变量前加上this关键字
      - }
- 1. 当不同的对象调用同一个方法时，由于调用方法的对象不同导致this关键字不同，从而this. 方式访问的结果也就随之不同
  - 例如：
    - PersonTwoTest pttOne = new PersonTwoTest("圣贤之人",19);
    - pttOne.show(); // "圣贤之人",19，对象不同导致this关键字不同
    - PersonTwoTest pttTwo = new PersonTwoTest();
    - pttTwo.showAge("CjShelby",1); // "CjShelby",1
- 1. 使用方式：
  - 1. 当局部变量与成员变量名相同时，在方法体中会优先使用局部(就近原则)，若希望使用成员变量，则需要在成员变量的前面加上 this. 的前缀，明确要求该变量时成员变量(重中之重)
    - 例如：
      - PersonTwoTest(String name ,int age){// 使用就近原则
      - this.name = name;
      - this.age = age;
      - }
      - PersonTwoTest pttTwo = new PersonTwoTest();
      - pttTwo.showAge("CjShelby",18);
  - 1. this关键字除了可以通过 this. 的方式调用成员变量和成员方法外，还可以作为方法的返回值(重点)
    - 例如：
      - // 自定义成员方法实现Person类型对象的获取并返回的行为
      - public PersonTwoTest getPersonTwoTest(){
      - return this;
      - }
      - PersonTwoTest prrFour = new PersonTwoTest();
      - PersonTwoTest personTwoTest = prrFour.getPersonTwoTest();
      - System.out.println(personTwoTest);
      - System.out.println(prrFour);
  - 3.在构造方法的第一行可以使用 this() 的方式来调用本类中的其他构造方法(了解即可，用得较少)
    - 例如：
      - ManWrite(String name){
      - this(); // this关键字再次调用无参构造方法ManWrite()
      - this.name = name;
      - System.out.println("有参构造方法");
      - ManWrite mwOne = new ManWrite("CjShelby");
      - mwOne.show(); // 先执行this调用的无参构造方法，在打印mwOne调用的show打印名字
  - 1. 引用变量的注意事项：
    - 1. 引用类型变量：
      - 功能：
        
        用于存放对象的地址，可以给引用类型赋值为Null,表示不指向任何对象
      - 注意：
        
        当某个引用类型变量为Null时无法对对象实施访问(因为它没有指向任何对象)
    - 1. 引用变量的数值可以为空
      - 例如:
        
        ManWrite m = null;
        
        m.show(); // 编译为空，运行会发生NullPointException空指针异常

12. 递归的概念(难点)：

1. 本质：
- 就是指在方法体的内部直接或间接调用当前方法自身的形式
- 注意：
  - 使用递归必须有递归的规律以及退出条件
  - 使用递归必须使得问题简单化而不是复杂化
  - 若递归影响到程序的执行性能，则使用递推取代之

13. 封装的概念(重中之重)：

1. 通常情况下可以在测试类给成员变量赋值一些合法但不合理的数值，无论是编译阶段还是运行阶段都不会报错或者给出提示，此时与现实生活不符
- 例如：
  - public class Student {
  - // 编程实现Student类的封装
  - // 1. 自定义成员变量名字和学号
  - String name ;
  - int id ;
  - public void show(){
  - System.out.println("我是:"+name+"我的学号："+id);
  - }
  - }
  - // 1. 声明Studt类型的引用变量并指向该类型的对象
  - Student s = new Student();
  - // 2. 对成员变量进行赋值并打印
  - s.id = -101002; // 合法但不合理，不会报错或给出提示，与现实中的学号是不符的
  - s.name = "CJShelby";
  - s.show();
1. 解决方法：
- 1. 为了避免上述错误的发生，就需要对成员变量进行密封包装处理，来隐藏成员变量的细节以及保证成员变量数值的合理性，该机制就叫做封装
1. 封装的实现流程：
- 1. 私有化成员变量，使用private关键字修饰
  - 例如：
    - // 1. 自定义成员变量名字和年龄,并使成员变量私有化使用private关键字修饰
    - private String name ;
    - private int id ;
- 1. 提供公有的get和set方法，并在方法体中进行合理值的判断
- 1. 在构造方法中调用set方法进行合理值的判断
  - 例如：
    - // 1. 自定义成员变量名字和年龄,并使成员变量私有化使用private关键字修饰,在成员方法中进行合理值的判断
    - private String name ;
    - private int id ;
    - // 2. 此时不可直接访问可以间接访问通过get和set
    - public void setId(int id){
    - if (id > 0){
    - this.id = id;
    - }else {
    - System.out.println("学号不合理哦！");
    - }
    - }
    - public int getId(){
    - return id;
    - }
    - public void setName(String name){
    - this.name = name;
    - }
    - public String getName(){
    - return name;
    - }
    - public void show(){
    - System.out.println("我是:"+getName()+"我的学号："+getId());
    - }
    - }

14. static关键字的基本概念：

1. 使用static关键字修饰成员变量表示静态的含义，此时成员变量由对象层级提升为类层级，也就是整个类只有一份并被所有对象共享
注意：
- 该成员变量随着类的加载准备就绪，与是否创建对象无关
  - 代码：
    - public class PeopleTest {
    - public static void main(String[] args) {
    - // 1. 声明People类型的引用变量并指向该类型的对象
    - System.out.println(People.country);// 与是否创建对象无关，可以直接类名.方式调用静态成员变量
    - People p = new People("CJshelby",18,"China");
    - // 2. 使用People类型的引用变量调用方法，并给set方法传参并使得get方法返回值
    - System.out.println("-------------------------------------------------");
    - p.setName("TomsShelby");
    - p.setAge(19);
    - p.setCountry("England");
    - p.show();
    - System.out.println("-------------------------------------------------");
    - // 验证static关键字修饰的静态成员(类成员):是否被所有对象共享
    - People.country = "中国";
    - System.out.println(People.country);
    - System.out.println(People.country);
    - }
    - }
1. static 关键字修饰的成员可以使用引用.方式访问，但推荐类名. 的方式
1. static的使用方式：
- 1. 在非静态成员方法中既能访问非静态的成员变量又能访问静态的成员
  - (成员：成员变量+成员方法，静态成员被所有对象共享)
    - 代码：
      - public class StaticTest {
      - // 编程实现static关键字的使用
      - public int ia = 1;
      - private static int ib = 2;
      - // 自定义show方法来实现打印
      - public void show(){
      - System.out.println("ia = "+ia);
      - System.out.println("ib = "+ib);// 非静态成员方法能访问静态成员变量
      - }
      - public static void main(String[] args) {
      - // 声明StaticTest类型的引用变量并指向该类型的对象
      - StaticTest st = new StaticTest();
      - st.show();
      - }
      - }
- 1. 在静态成员方法中只能访问静态成员不能访问非静态成员
  - (成员: 成员变量 + 成员方法，因为此时可能还没有创建对象)
  - 代码：
    - public int ia = 1;
    - private int ib = 2;
    - public void static test(){
    - System.out.println("ia ="+ia); // 错误写法，静态成员方法中只能访问静态成员变量不能访问非静态成员变量
    - System.out.println("ib = "+ib);
    - }
- 1. 在以后的开发中只有隶属于类层级并被所有对象共享的内容才可以使用static关键字修饰(不能滥用static关键字)

15. 构造块和静态代码块(熟悉)：

1. 构造块：
- 1. 在类体中直接使用 {} 括起来的代码块
- 何时使用：
  - 当需要在执行构造方法体之前做一些准备工作时，则将准备工作的相关代码写在构造块中即可
  - 例如：
    - public class BlockTest {
    - // 编程实现构造块和静态代码块的使用
    - {
    - System.out.println("构造块！");
    - }// 构造块
    - //自定义构造方法
    - public BlockTest(){
    - System.out.println("构造方法！"); // 构造方法执行时先执行构造块里的代码
    - }
    - public static void main(String[] args) {
    - BlockTest bt = new BlockTest();
    - }
    - }
- 1. 没创建一个对象都会执行一次构造方法
1. 静态代码块：
- 1. 使用 static 关键字修饰的构造块
  - 注意：
    - 静态代码块会随着类的加载而准备就绪，会先于构造块执行
    - 例如：
      - {
      - System.out.println("构造块！");
      - }// 构造块
      - static{
      - System.out.println("########静态代码块！");
      - }
      - //自定义构造方法
      - public BlockTest(){
      - System.out.println("构造方法！");
      - }
      - public static void main(String[] args) {
      - BlockTest bt = new BlockTest();
      - BlockTest bt1 = new BlockTest();
      - }
      - }
- 1. 静态代码块随着类加载时执行一次
- 1. 何时使用：
  - 当需要在执行代码块之前随着类的加载做一些准备工作时，则编写代码到静态代码块中

16. 又见main方法：

语法格式：
- public static void main(String[] args){}

17. 单列设计模式：

1. 在某些特殊场合中，一个类对外提供且只提供一个对象时，这样的类叫单例类，而设计单例的流程和思想叫做单例设计模式
1. 单例设计模式的实现流程(类似饿汉式写法)：
- 1. 私有化构造方法，使用private关键字修饰
- 1. 声明本类类型的引用指向本类类型的对象，并使用private static 关键字共同修饰
- 1. 提供公有的get方法负责将对象返回出去，并使用public static 关键字共同修饰
  - 代码：
    - public class Singleton {
    - // 编程实现Singleton类的封装
    - // 1. 私有化构造方法使其创建的引用变量无法成功创建对象并无法同时调用构造方法
    - // 2. 使用Singleton类型调用自身类型
    - private static Singleton sOne = new Singleton();
    - public static Singleton getInstance(){
    - return sOne;
    - }
    - private Singleton(){}
    - }
    - System.out.println("-------------------------------------------------------");
    - public class SingletonTest {
    - public static void main(String[] args) {
    - // 声明Singleton类型的引用变量并指向该类型的对象
    - //Singleton s = new Singleton();
    - //Singleton s1 = new Singleton();
    - Singleton selve = Singleton.getInstance();
    - Singleton selveOne = Singleton.getInstance();
    - System.out.println(selve == selveOne);
    - }
    - }

18. 继承：

1. 继承的概念：
- 1. 当多个类之间有相同的特征和行为时，可以将相同的内容提取出来组成一个公共类，让多个类吸收公共类中已有特征和行为而在多个类型只需要编写自己独有特征和行为的机制，叫继承
- 1. 在JAVA语言中使用 extends(扩展) 关键字来表示继承关系
  - 例如：
    - public class Worker extends Person{} // 表示Worker类继承字Person类
    - 其中Person类叫做父类
    - 其中Worker类叫做子类
- 1. 使用继承提高了代码的服用性，可维护性及扩展性，是多态的前提条件
1. 继承的特点：
- 1. 子类不能继承父类的构造方法和私有方法，但私有成员变量可以被继承只是不能直接访问
- 1. 无论使用何种方式构造子类的对象时都会自动调用父类的无参构造方法，来初识化父类中继承的成员变量，相当于在构造方法的第一行增加代码 super() 的效果
  - 例如：
    - public class Worker extends PersonThey {
    - // 1. 私有化成员变量
    - private int salery;
    - // 3. 在构造方法中进行合理值判断
    - public Worker(){
    - super(); // 表示调用父类的无参构造方法，若没有加则编译器默认自动添加
    - }
    - public Worker(String name ,int age ,int salery){
    - super(name,age); // 调用父类的有参构造方法，可以注释掉setName和setAge，因为super(name,age)方法已经调用了父类里的setName和setAge
    - // setName(name);
    - // setAge(age);
    - setSalery(salery);
    - }
    - // 2. 使用set和get方法获取工资并进行合理值判断
    - public void setSalery(int salery){
    - if (salery > 2200) {
    - this.salery = salery;
    - }else {
    - System.out.println("薪资不合理哦！！！！");
    - }
    - }
    - public int getSalery(){
    - return salery;
    - }
    - }
- 1. 使用继承必须满足逻辑关系：子类 is a 父类，也就是不能滥用继承
- 1. JAVA语言只支持单继承不支持多继承，也就是说一个子类只能有一个父类，但一个父类可以有多个子类

19. 方法重写的概念和使用：

1. 从父类中继承下来的方法不满足子类的需求时，就需要在子类中重写一个和父类一样的方法来覆盖从父类中继承下来的版本，该方式叫做方法的重写(Override)
- 例如：
  - // 1. 自定义Worker类继承字PersonThey
  - public class Worker extends PersonThey {
  - // 1. 私有化成员变量
  - private int salery;
  - // 3. 在构造方法中进行合理值判断
  - public Worker(){
  - super();
  - }
  - public Worker(String name ,int age ,int salery){
  - super(name,age); //
  - // setName(name);
  - // setAge(age);
  - setSalery(salery);
  - }
  - // 2. 使用set和get方法获取工资并进行合理值判断
  - public void setSalery(int salery){
  - if (salery > 2200) {
  - this.salery = salery;
  - }else {
  - System.out.println("薪资不合理哦！！！！");
  - }
  - }
  - public int getSalery(){
  - return salery;
  - }
  - // 自定义show方法覆盖从父类继承的版本
  - @Override // 注解，
  - public void show(){
  - super.show();//表示调用父类的show方法
  - System.out.println("我在北京的薪水是"+getSalery());
  - }
  - }
1. 方法重写的原则：
- 1. 要求方法名相同，参数列表相同以及返回值类型相同，从java5开始允许返回子类类型
- 1. 要求方法的访问权限不能变小，可以相同或者变大
- 1. 要求方法不能抛出更大的异常(异常机制)

20. 又见构造块与静态代码块(笔试):

1. 先执行父类的静态代码块，再执行子类的静态代码块
1. 执行父类的构造块(代码块)，执行父类的构造方法体
1. 执行子类的构造块(代码块)，执行子类的构造方法体

21. 权限修饰符和包的定义：

1. 常用的访问控制符：
- a. public:
  - 一路绿灯
- b. protected:
  - 本类：
    - 可以访问
  - 同一个包中的类：
    - 可以访问
  - 子类：
    - 可以访问
  - 其他类：
    - 不能访问
- c. 默认：
  - 本类：
    - 可以访问
  - 同一个包中的类：
    - 可以访问
  - 子类：
    - 不能访问
  - 其他类：
    - 不能访问
- d. private:
  - 本类：
    - 可以访问
  - 同一个包中的类：
    - 不能访问
  - 子类：
    - 不能访问
  - 其他类：
    - 不能访问
- 注意事项：
  - a. public 修饰的成员可以在任意位置使用
  - b. private 修饰的成员只能子啊本类内部使用
  - c. 通常情况下，成员方法都使用 public 关键字修饰，成员变量都使用 private 关键字修饰
1. package语句的由来：
- 1. 在JAVA语言中，用包(packge)的概念来解决命名冲突的问题(其实就是创建目录)
- 1. 格式：
  - 1. package 包名 (创建单层包文件夹)；
  - 1. package 包名1.包名2.包名3...包名n (创建多层包文件夹)
  - 好处：
    - 为了实现项目管理，解决命名冲突以及权限控制的效果
- 1. 定义包的规范：
  - 例如：com.Lagou.Study
- 1. 包的导入：
  - 使用import关键字导入包
  - 使用import关键字导入静态成员，从java5.0开始支持

22. final修饰类和方法的作用：

1. final(最终的，不可改变的):
- 作用：
  - 可以修饰类，成员方法以及成员变量
1. 使用方式：
- 1. final关键字修饰类体现在该类不能被继承
  - 主要用于防止滥用继承
  - 例如：
    - public /final/ class FinalClass {
    - public final void show(){
    - System.out.println("Final类中的show方法");
    - }
    - }
- 1. final关键字修饰成员变量方法体现在该方法不能被重写但可以被继承
  - 主要用于防止不经意间造成重写
  - 例如：
    - public class SubFinalClass extends FinalClass{
    - @Override
    - public void show(){
    - System.out.println("SubFinalClass");
    - }
    - }
- 1. final关键字修饰成员变量体现在该变量必须初识化不能改变
  - 主要用于防止不经意间造成改变
  - 例如：
    - public class FinalMenberTest {
    - // private final int cnt = 1; // cnt 已经在构造方法体中或构造代码块中初始化，不能改变初始化的值
    - /*private final int cnt;
    - {
    - cnt = 20;// 构造代码块中进行初始化
    - }*/
    - public final int cnt;
    - public FinalMenberTest(){
    - cnt = 2;// 构造方法体中进行初始化
    - }
    - public static void main(String[] args) {
    - // 声明FinalMenberTest类型的引用变量并指向该类型的对象
    - FinalMenberTest fmt = new FinalMenberTest();
    - System.out.println("fmt.cnt = "+ fmt.cnt);
    - }
1. 常量的概念：
- 在以后的开发过程中很少单独使用final关键字来修饰成员变量，通常使用 public static final 关键字共同修饰成员变量来表达常量的含义，常量的命名规范要求所有字母都要大写，不同的单词之间用下划线连
- 例如：
  - public static final double PI = 3.14;

23. 多态的概念(重中之重)：

1. 同一种事物表现出来的多种形态
- 例如：
  - 饮料：可乐，雪碧，红牛，脉动...
1. 语法格式：
- 父类类型引用变量名 = new 子类类型();
  - 例如：
    - Shape sr = new Rect();
    - sr.show();
1. 注意：("披着羊皮的狼"原理)
- 代码在编译阶段调用Shape类的show方法，在运行阶段调用Rect类中的show方法：
  - 代码：
1. 多态的特点：
- 1. 当父类类型的引用指向子类类型的对象时，父类类型的引用可以直接调用父类独有的方法
  - 代码：
    - public class ShapeRectTest {
    - public static void main(String[] args) {
    - // 1. 声明Shape类型引用变量并指向该类型的对象并打印
    - Shape s = new Shape(1,2);
    - s.show();
    - System.out.println("-----------------------------------");
    - // 2. 声明Rect类型的引用变量并指向该类型的对象并打印
    - Rect r1 = new Rect(3,3,4,5);
    - r1.show();
    - System.out.println("-----------------------------------");
    - // 3. 声明Shape类型的引用变量并指向该类型的对象并打印
    - // daRect类中重写show方法后，下面的代码在编译阶段调用Shape类的show方法，在运行阶段调用Rect类中的show方法
    - Shape sr = new Rect(7,8,9,10);
    - sr.show();
    - System.out.println("-----------------------------------");
    - System.out.println(sr.getX()); // 父类类型的引用可以直接调用父类独有的方法
    - }
    - }
- 1. 当父类类型的引用指向子类类型的对象时，父类类型的引用不可以直接调用子类独有的方法
- 1. 对于父子类都有的非静态方法来说，编译阶段调用父类版本，运行阶段调用子类重写的版本(动态绑定)
- 1. 对于父子类都有的静态方法来说，编译和运行阶段都调用父类版本
1. 引用数据类型之间转换的方式：
- 1. 自动类型转换：
  - 小类型向大类型的转换，也就是子类转为父类，也叫做向上转型
- 1. 强制类型转换：
  - 大类型向小类型的转换，也就是父类转为子类，也叫做向下转型或显示类型转换
  - 格式：
    - 父类数据类型变量名 =（(子类引用)父类引用).要访问的方法；
- 1. 引用数据类型转换的注意事项：
  - 1. 引用数据类型之间的转换必须发生在父子类之间，否则编译报错
  - 1. 若强转的目标类型并不是该引用真正指向的数据类型时则编译通过，运行阶段发生类型转换异常
  - 1. 解决方案：
    - 为了避免上述错误的发生，应该在强转之前进行判断
      - 格式：
        
        if(引用变量 instanceof 数据类型)
        
        判断引用变量指向的对象是否为后面的数据类型
1. 多态的实际意义：
- 在于屏蔽不同子类的差异性实现通用的编程带来不同的效果
- 例如：
  - public class ShapeTest{
  - // 自定义成员方法实现既能打印横纵坐标又能打印圆的半径
  - public static void draw(Shape s){ // 多态的另一种写法，把类类型作为形参通过类名. 的方式调用不同子类的方法并在括号里创建子类(new Rect(...)/Circle(...))给形参父类(Shape s)
  - s.show();
  - }
  - public static void main(String[] args) {
  - ShapeTest.draw(new Rect(1,2,3,4));
  - ShapeTest.draw(new Circle(5,6,7));
  - }
  - }

24. 抽象方法的概念(重点):

1. 不能具体实现的方法并且使用 abstract 关键字修饰，也就是没有方法体
1. 格式：
- 访问权限 abstract 返回值类型方法名(形参列表);
- 例如：
  - public abstract void cry();
1. 抽象类的概念：
- 1. 不能具体实例化的类并且使用 abstract 关键字修饰，也就是不能创建对象
1. 抽象类和抽象方法的关系：
- 1. 抽象类中可以有成员变量，构造方法，成员方法
- 1. 抽象类中可以没有抽象方法，也可以有抽象方法
- 1. 拥有抽象方法的类必须是抽象类，因此真正意义上的抽象类因该是具有抽象方法并且使用 abstract 关键字修饰的类
1. 抽象类的实际意义：
- 1. 不在于创建对象而在于被继承
- 1. 当一个类继承抽象类后必须重写抽象方法，否则该类也变成抽象类，也就是抽象类对子类具有强制性和规范性，因此叫做模板设计模式
- 1. 抽象类中多态的使用场合之二：
  - 直接在方法体中使用抽象类的引用指向子类类型的对象
- 1. 开发经验分享：
  - 在以后的开发中推荐使用多态的格式，此时父类类型引用直接调用的所有方法一定是父类中拥有的方法，若以后更换子类时，只需要将 new 关键字后面的子类类型修改而其他地方无需修改就可以立即生效，从而提高了代码的可维护性和可扩展型
  - 该方法的缺点：
    - 父类引用不能直接调用子类独有的方法，若调用则需要强制类型转换
1. 笔试考点：
- 抽象方法不能出现 private, final, static
- 例如:
  - private abstract double getLxi();
  - public fianl abstract double getLxi();
  - public static abstract double getLxi();

25. 接口的基本概念(重点)：

1. 就是一种比抽象类还抽象的类，体现在所有的方法都为抽象方法
1. 定义类的关键字是 class , 而定义接口的关键字是 interface
- 例如：
  - public interface Matal {
  - // 抽象方法描述铁方法
  - public void showMatal();
  - }
  - public interface Money {
  - // 抽象方法描述钱
  - public void showMoney();
  - }
  - public class Gold implements Matal,Money{
  - @Override
  - public void showMatal() {
  - System.out.println("发出金黄色的光芒！");
  - }
  - @Override
  - public void showMoney() {
  - System.out.println("买了好多好吃的！");
  - }
  - public static void main(String[] args) {
  - // 1. 声明接口类型的引用变量指向实现类对象
  - Matal m = new Gold();
  - m.showMatal();
  - Money m1 = new Gold();
  - m1.showMoney();
  - }
  - }
1. 注意：
- 接口只能继承接口，不能继承普通类
1. 类和接口之间的关系：
- 1. 类和类之间的关系 ---》使用 extends 关键字表达继承关系 ---》支持单继承
- 1. 类和接口之间的关系 ---》使用 implements 关键字表达实现关系 ---》支持多实现
- 1. 接口和接口之间的关系 ---》使用 extends 关键字表达继承关系 ---》支持多继承
1. 接口和抽象类的主要区别：
- 1. 定义抽象类的关键字是 abstract class , 而定义接口的关键字是 interface
- 1. 继承抽象类的关键字是 extends ,而实现接口的关键字是 implements
- 1. 继承抽象类支持单继承，而实现接口支持多实现
- 1. 抽象类中可以有构造方法，而接口中不可以有构造方法
- 1. 抽象类中可以有成员变量，而接口中只可以有常量
- 1. 抽象类中可以有成员方法，而接口中只可以有抽象方法
- 1. 抽象类中增加方法时子类不可以重写，而接口中增加方法时实现类需要重写(java8以前的版本)
- 1. 从JAVA8开始增加新特性，接口中允许出现非抽象方法和静态方法，但非抽象方法需要使用 default 关键字修饰
  - 何时使用非抽象方法：
    - 如果在实现类中不想牵一发而动全身重写抽象方法，就使用 default 关键字修饰该方法
    - 例如：
      - public interface Runing {
      - // 自定义奔跑的抽象方法
      - public abstract void run();
      - public static void show(){
      - System.out.println("我是接口中的静态方法！");
      - }
      - public default void showOne(){
      - System.out.println("我是接口中的非抽象方法！");
      - }
      - }
- 9.从JAVA9开始增加新特性，接口中允许出现私有方法
  - 目的：
    - 为了在接口中实现代码的复用
    - 例如：
```
public interface Hunder extends Runing{
 // 自定义hunder抽象类方法
public abstract void hunder();
private default void show(){// 为了让外部接口不能调用此私有默认方法
   System.out.println("在以后的开发中尽量减少重复的代码，也就是减少代码的冗余！");
 }
    
public default void showO(){n dfj
    show();
    System.out.println("Hunder1接口中的非抽象方法默认实现实现类可以自由选择是否重写");
 }
    
public default void showTwo(){
 show();
 System.out.println("Hunder1接口中的非抽象方法默认实现实现类可以自由选择是否重写");
 }
    
public static void need(){
  System.out.println("这里是静态方法，可以直接通过 类名. 的方式调用，省略对象的创建");
    }
  }
```

26. 内部类的基本概念：

1. 当一个类的定义出现在另一个类的类体中，那么这个类叫做内部类(Inner),而这个内部类所在的类叫做外部类(Outer)
1. 类中的内容：
- A. 成员变量，B. 成员方法，C. 构造方法，D. 静态方法，E. 构造快和静态代码块，F. 内部类
1. 实际作用：
- 当一个类存在的价值仅仅是为某一个类单独服务时，那么就可以将这个类定义为服务类中的内部类，这样可以隐藏该类的实现细节并且可以方便的访问外部类的私有成员而不再需要提供公有的get和set方法
1. 内部类的分类：
- 1. 普通(成员)内部类：
  - A. 直接将一个类的定义放在另一个类的类体中
  - B. 格式：
    - 访问修饰符 class 外部类的类名{
    - 访问修饰符 class 内部类的类名{
      - 内部类的类体；
      - }
    - }
  - C. 普通内部类的使用方式：
    - 1. 普通内部类和普通类一样可以定义成员变量，成员方法以及构造方法等
    - 1. 可以使用 final 或者 abstract 关键字选修
    - 1. 还可以使用 private 或 protected 关键字进行修饰
    - 普通内部类需要使用外部类对象来创建对象
      - 例如：
        
        位于：package com.Cjshelby.TaskOne.NormalOuterTest
        
        // 声明NormalOuter类型的引用变量并指向该类型的对象
        
        NormalOuter no = new NormalOuter();
        
        // 调用内部类中的show方法
        
        NormalOuter.NormalInner ni = no.new NormalInner();
        
        ni.show();
    - 1. 如果内部类与外部类中的成员变量或方法同名时，需要使用 this 关键字
      - 内部类调用内部类中的成员变量
        
        this.成员变量名
      - 在内部类中调用外部类中的成员变量
        
        外部类名.this.外部类中的成员变量
- 1. 静态内部类：
  - A. 使用 static 关键字修饰的内部类，隶属于类层级
  - B. 格式：
    - 访问修饰符 class 外部类的类名{
      - 访问修饰符 static class 内部类的类名{
        
        内部类的类体；
      - }
    - }
  - 例如：
    - public class StaticOuterTest {
    - public static void main(String[] args) {
    - // 1. 声明StaticInner类型的引用指向该类型的对象
    - StaticOuter.StaticInner so = new StaticOuter.StaticInner();
    - // 2. 调用内部类的show方法
    - so.show();
    - }
    - }
  - C. 静态内部类的使用方式：
    - 1. 静态内部类不能直接访问外部类的非静态成员变量
    - 1. 静态内部类可以直接创建对象
    - 1. 如果静态内部类访问外部类中与静态内部类的成员变量或方法同名，需要使用类名. 的方式访问
- 1. 局部 (方法) 内部类：
  - A. 直接将一个类的定义放在方法体的内部时
  - B. 格式：
    - 访问修饰符 class 外部类的类名{
      - 访问修饰符返回值类型成员方法名 (形参列表){
        
        class 内部类的类名{
        
        内部类的类体;
        
        }
      - }
    - }
  - 例如：
    - public class AreaOuter {
    - private int cnt = 1;
    - public void show(){
    - // 定义局部内部类，只在当前方法体内部好使
    - class AreaInner{
    - private int ia = 2;
    - public AreaInner(){
    - System.out.println("局部内布类的构造方法！");
    - }
    - public void test(){
    - System.out.println("ia = "+ia);
    - System.out.println("cnt "+cnt);
    - }
    - }
    - // 声明局部内部类的引用指向局部内部类的对象
    - AreaInner ai = new AreaInner();
    - ai.test();
    - }
    - public class AreaOuterTest {
    - public static void main(String[] args) {
    - // 1. 声明外部类类型的引用指向外步类的对象
    - AreaOuter ao = new AreaOuter();
    - // 2. 通过show方法的调用实现局部内部类的定义和使用
    - ao.show();
    - }
    - }
  - C. 局部内部类的使用方式：
    - 1. 局部内部类只能在该方法的内部可以使用
    - 1. 局部内部类可以在方法体内部直接创建对象
    - 1. 局部内部类不能使用访问控制符和 static 关键字修饰符
    - 1. 局部内部类可以使用外部方法的局部变量，但是必须时 final 的。有局部内部类和局部变量的声明周期不同所致
  - D. 回调模式的概念：
    - 1. 如果一个方法的参数是接口类型，则在调用该方法时，需要创建并传递一个实现此接口类型的对象；而该方法在运行时会调用到参数对象中所实现的方法(接口中定义的)
- 1. 匿名内部类(重点)：
  - A. 没有名字的内部类
  - B. 匿名内部类的使用：
    - 开发经验分享：
      - 当借口/类类型的引用作为方法的形参时，实参的传递方式有两种：
        
        自定义类实习接口/继承类并重写方法，然后得到该类对象作为实参传递
        
        使用上述匿名内部类的的语法格式得到接口/ 类型的引用即可
  - C. 匿名内部类的语法格式(重点)：
    - 接口/父类类型引用变量名 = new 接口/父类类型(){方法的重写};

27. 枚举的基本概念：

1. 在日常生活中这些事物的取值只有明确的几个固定值，此时描述这些事物的所有值都可以挨个列举出来，而这个列举出来的类型就叫做枚举类型
1. 枚举类型的定义:
- a. 使用 public stati final 表示的常量描述较为繁琐，使用 enum 关键字来定义枚举类型取代常量，枚举类型是从JAVA5开始增加的一种引用数据类型
- b. 枚举值：
  - 就是当前类的类型，也就是指向本类的对象，默认使用 public static final 关键字共同修饰，因此采用枚举类型. 的方式调用
- c. 枚举类可以自定义构造方法，但是构造方法的修饰符必须是 private，默认也是私有的
  - 例如：
    - public enum DirectionEnum {
    - // 向上，下，左，右
    - UP("向上"),DOWN("向下"),LEFT("向左"),RIGHTE("向右");
    - private final String dsc;
    - // 实现成员变量的初识化
    - private DirectionEnum(String dsc) {
    - this.dsc = dsc;
    - }
    - public String getDsc() {
    - return dsc;
    - }
    - }
1. Enum类的概念和方法：
- 所有的枚举都继承自java.lang.Enum类，常用方法如下：
  - 1. static T[] values():
    - 返回当前枚举类中的所有对象
  - 1. String toString():
    - 返回当前枚举类对象的名称
  - 1. int ordinal():
    - 获取枚举对象在枚举类中的索引位置
  - 1. static T valuesOf(String str):
    - 将参数指定的字符串名转为当前枚举类的的对象
  - 1. int compareTo(E o):
    - 比较两个对象在定义时的顺序
1. 枚举类实现接口的方式：
- 枚举实现接口后需要重写抽象方法，而重写方法的方式有两种：
  - 1. 重写一个
    - 代码：
      - public enum DirectionEnum implements DirectionInterface{
      - // 向上，下，左，右
      - UP("向上"), DOWN("向下"), LEFT("向左"), RIGHTE("向右");
      - private final String dsc;
      - // 实现成员变量的初识化
      - private DirectionEnum(String dsc) {
      - this.dsc = dsc;
      - }
      - public String getDsc() {
      - return dsc;
      - }
      - @Override
      - public void show() {
      - System.out.println("现在可以实现接口类中的抽象方法了！");
      - }
      - }
  - 1. 或者每个对象都重写
    - 代码：
      - public enum DirectionEnum implements DirectionInterface{
      - // 向上，下，左，右
      - UP("向上"){
      - @Override
      - public void show() {
      - System.out.println("贪吃蛇向上移动了！");
      - }
      - },DOWN("向下"){
      - @Override
      - public void show() {
      - System.out.println("贪吃蛇向下移动了！");
      - }
      - },LEFT("向左"){
      - @Override
      - public void show() {
      - System.out.println("贪吃蛇向左移动了！");
      - }
      - },RIGHTE("向右"){
      - @Override
      - public void show() {
      - System.out.println("贪吃蛇向右移动了！");
      - }
      - };
      - private final String dsc;
      - // 实现成员变量的初识化
      - private DirectionEnum(String dsc) {
      - this.dsc = dsc;
      - }
      - public String getDsc() {
      - return dsc;
      - }

28. 注解(Anntation)的概念:

A. 又叫标注，是从JAVA5开始增加的一种引用数据类型
B. 注解本质：
- 就是代码中的特殊标记，通过这些标记可以在编译，类加载，以及运行时执行指定的处理
C. 格式:
- 访问修饰符 @interface 注解名称{
  - 注解成员;
- }
- 注意：
  - 1. 自定义注解自动继承 java.lang.annotation.Annotation接口
  - 1. 通过@注解名称的方式可以修饰包,类，成员方法，成员变量，构造方法，参数，局部变量的声明等
D. 注解的使用方式：
- 1. 注解体中只有成员变量没有成员方法，而注解的成员变量以"无形参的方法"形式来声明，其方法名定义了改成员变量的名字，其返回值定义了该成员变量的类型
  - 代码：
    - public @interface MyAnnotation {
    - public String value();
    - }
- 1. 如果注解只有一个参数成员，建议使用参数名为 value, 而类型只能是八种基本类型，String类型，Class类型，enum类型及Annotation类型
E. 元注解的概念：
- 1. 可以注解到注解上的注解，或者说元注解是一种基本注解，但是它能够应用到其他的注解上面
- 1. 元注解主要有：
  - 1. @Retention:
    - a. @Retention 应用到一个注解上用于说明该注解的生命周期，取值如下：
      - RetentionPolicy.SOURCE 注解只在源代码阶段保留，在编译器进行编译时它将被丢弃忽视
      - RetentionPolicy.CLASS 注解只被保留到编译进行的时候，它并不会被加载到JVM 中，默认方式
      - RetentionPolicy.RUNTIME 注解可以保留到程序运行的时候，他会被加载进入 JVM 中，所以在程序运行时可以获取到它们
  - 1. @Documented：
    - a. 作用：
      - 用于指定被该注解将被 javadoc 工具提取器成文档
      - 注意：
        
        定义为@Documented的注解必须设置Retention值为RUNTIME
  - 1. @Target:
    - 作用:
      - 用于指定被修饰的注解能用于哪些元素的修饰，取值如下：
        
        ElementType.ANNOTATION_TYPE:
        
        可以给一个注解进行注解
        
        ElementType.CONSTRUCTOR:
        
        可以给构造方法进行注解
        
        ElementType.FIELD:
        
        可以给属性 (成员变量) 进行注解
        
        ElementType.LOCAL_VARIABLE:
        
        可以给局部变量进行注解
        
        ElementType.METHOD:
        
        可以给方法进行注解
        
        ElementType.PACKAGE:
        
        可以给一个包进行注解
        
        ElementType.PARAMETER:
        
        可以给一个方法内的参数进行注解
        
        ElementType.TYPE:
        
        可以给类型进行注解，比如类，接口，枚举
  - 1. @Inherited:
    - 解释说明：
      - @inherited并不是说注解本身可以继承，而是说如果一个父类被该注解标记过的注解进行注解时，如果子类没有被任何注解应用时，则子类就继承父类的注解
  - 1. @Repeatable:
    - a. 解释说明：
      - @Repeatable表示自然可重复的含义，从 JAVA8 开始增加的新特性
    - b. 从 java8 开始对元注解 @Target 的参数类型ElementType 枚举值增加了两个：
      - 其中ElementType.TYPE_PATAMETER 表示该注解能写在类型变量的声明语句中，如：泛型
      - 其中ElementType.TYPE_USE 表示该注解能写在使用类型的任何语句中
F. 常见的预制注解：
- a. 就是 java 语言自身提供的注解，具体如下：
  - 1. @author:
    - 标明开发该类模块的作者，多个作者之间使用，分割
  - 1. @version:
    - 标明该类模块的版本
  - 1. @see:
    - 参考转向，也就是相关主题
  - 1. @since:
    - 从哪个版本开始增加的
  - 1. @param:
    - 对方法中某参数的说明，如果没有参数就不能写
  - 1. @returm:
    - 对方法返回值的说明，如果方法的返回值类型是 void 就不能写
  - 1. @exception:
    - 对方法可能抛出的异常进行说明
- b. 常用的预制注解如下：
  - 1. @Override:
    - 限定重写父类方法，该注解只能用于方法
  - 1. @Deprecated:
    - 用于表示所修饰的元素 (类，方法等)已过时
  - 1. @SuppressWarnings:
    - 抑制编译器警告

29. 遇到的超前知识:

1. 字母转换成字母：
- a. 使用 Integer. parseInt(要转换成数字的字母字符串)；
  - 代码：
    - String str = "11121315141516";
    - int i1 = Integer.parseInt(str);
    - System.out.println(i1);
- b. toLowerCase（）：
  - 作用：
    - 用于把字符串转换为小写
  - 语法：
    - stringObject.toLowerCase();
  - 返回：
    - 一个全部转为小写的字符串
  - 原字符串：
    - 不改变
  - 代码：
    - String str = new String("TEST");
    - str.toLowerCase();
    - System.out.println(str)// 结果：TEST
- c. StringBuffer:
  - StingBuffer对象则代表一个字符序列可变的字符串
  - 作用：
    - 可以通过StringBuffer提供的方法改变字符串对象的字符序列
  - 代码：
    - StringBuffer b = new StringBuffer("123");
    - b.append("456");
    - System.out.println(b)// 结果：123456
- d. toCharArray:
  - 作用：
    - 将字符串转换为字符数组
  - 语法：
    - public char[] toCharArray()
  - 返回值：
    - 字符数组
  - 代码：
    - public class Test{
      - public static void main(String[] args){
        
        String str = new String("Hello,World!");
        
        System.out.println("返回值: ");
        
        System.out.pritln(str.toCharArray()); // 结果： Hello，World!
      - }
    - }
- e. valueOf():
  - 作用：
    - 用于返回指定对象的原始值
  - 返回值：
    - 返回指定对象的原始值
  - 代码：
- f. charAt(): 索引范围从 0 到 length - 1
  - 语法：
    - public char charAt(int index)
  - 参数：
    - index: 字符的索引
  - 返回值：
    - 返回值指定索引处的字符
  - 代码：
    - public class Test{
    - public static void main(String[] args){
      - String s = "www.runood.com";
      - char result = s.charAt(8);
      - System.out.println(result); // 字母： o
    - }
    - }

CjShelby

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
java中阶段详细笔记(没有之一！)

java面向对象编程1.面向对象编程的概念(理解): 万物皆对象面向对象：指以 (属性)或 (特征) 和 (行为) 的观点去分析现实生活中的事物 2. 面向对象编程：指先以面向对象的思想进行分析，然后使用面向对象的编程语言进行表达的过程。 3. 类和对象的概念：对象(具体客观的某一个)：指现实生活中客观存在的实体，在 JAVA 语言中对象体现为内存空间中的一块存储区域功能：
复制链接

扫一扫