Java学习笔记（二）

最新推荐文章于 2024-05-13 21:50:21 发布

掉发阿龙

最新推荐文章于 2024-05-13 21:50:21 发布

阅读量262

点赞数 2

分类专栏： Java基础

本文链接：https://blog.csdn.net/qq_45184360/article/details/115361208

版权

Java基础专栏收录该内容

13 篇文章 0 订阅

订阅专栏

本文详细介绍了Java中字符串的创建、特点、常量池以及比较方法。此外，还讲解了字符串的获取、截取、转换和分割操作。接着，讨论了Java中的静态关键字，包括静态成员变量和静态方法的使用规则。最后，简要阐述了继承的概念、特点以及构造方法的调用规则。

摘要由CSDN通过智能技术生成

Java学习笔记（二）

字符串

java.lang.String 类代表字符串

API当中说，Java程序中的所有字符串字面值（如“abc”）都作为此类的实例实现

其实就是说，程序当中所有的双引号字符串都是 String 类的对象（就算没有new,也照样是）

字符串的特点：

字符串的内容永不可变是一个常量
因为字符串用不可变所有字符串是可以共享使用的
字符串效果上相当于是 char[] 字符数组，但底层原理是 byte[] 字节数组

创建字符串的常见3+1中方式：

三种构造方法：

public String();//创建一个空白字符串，不含任何内容
public String(char[] array);//根据字符数组的内容，来创建对应的字符串
public String(byte[] array);//根据字节数组的内容，来创建对应的字符串

一种直接创建

//使用空参构造
String str1 = new String();//小括号留空，说明字符串什么内容也没有
//根据字符数组创建字符串
char[] charArray = {'A','B','C'};
String str2= new String(charArray);
System.out.println(str2);//ABC
//根据字节数组创建字符串
byte[] byteArray = {97,98,99};
String str3= new String(byteArray);
System.out.println(str3);//abc
//直接创建(直接写上双引号就是字符串对象)
String str4 = "Hello";

字符串常量池

/*
字符串常量池，程序当中直接写上双引号字符串，就在字符串常量池中
双引号直接写的字符串在常量池中，new的不在池当中

对于基本类型来说，==是进行数值的比较
对于引用数据类型来说，==是进行地址值的比较
*/
String str1 = "abc";
String str2 = "abc";

char[] charArray = {'a','b','c'};
String str3 = new String(charArray);

System.out.ptintln(str1 == str2);//true
System.out.ptintln(str1 == str3);//false
System.out.ptintln(str2 == str3);//false

在这里插入图片描述

字符串的比较相关方法

public boolean equals(Object obj)//参数可以是任意类型，只要参数是一个字符串并且内容相同才是true
public boolean equalsIgnoreCase(String str)//忽略大小写做比较
/*
==是进行对象的地址值比较，如果确实需要字符串内容的比较，可以使用两个方法：

注意：
1、任何对象都能用Object进行接收
2、equals方法具有对称性，a.equals(b)和b.equals(a)是相同的
3、如果比较双方一个常量一个变量，推荐把字符串写在前面
*/
String str5 = null;
//推荐写法
System.out.println("abc".equals(str5));//false
//不推荐写法
System.out.println(str5.equals("abc"));//报错，空指针异常

字符串的获取相关方法

public int length()//获取字符串中含有的字符个数，拿到字符串长度
public String concat(String str)//将当前字符串和参数字符串拼接成为返回值新的字符串
public char charAt(int index)://获取指定索引位置的单个字符（索引从0开始）
public int indexOf(String str)//查找参数字符串在本字符串中首次出现的索引位置，如果没有返回-1

字符串的截取相关方法

public String substring(int index)//截取从参数位置一直到字符串末尾，返回字符串
public String substring(int begin,int end)//截取从begin开始一直到end结束，中的字符串（[begin,end)包含走遍不包含右边）

/*
下面这种写法，字符串内容仍然是没有改变的
strA当中保存的是地址值
修改strA后地址值发生改变
*/
String strA = "Hello";
System.out.println(strA);//Hello
strA = "Java";
System.out.println(strA);//Java

字符串的转换相关方法

public char[] toCharArray()//将当前字符串拆分为字符数组作为返回值
public byte[] getBytes()//获得当前字符串底层的字节数组
public String replace(CharSequence oldString,CharSequence newString)//将所有出现的老字符串替换成新的字符串返回替换后的结果（CharSequence意思是可以接收字符串类型）

字符串的分割方法

public String[] split(String regex)//按照参数的规则将字符串切分成为若干部分
/*
注意：
split方法的参数是一个正则表达式
如果按照英文据点"."去切分必须写"\\."(两个反斜杠)否则切分失败
*/
String str1 = "aaa,bbb,ccc";
String[] array1 = str1.split(",");
for(int i = 0;i < array1.length;i++){
    System.out.ptintln(array1[i]);
}

静态static关键字

一旦使用 static 关键字,那么这样的内容不再属于对象自己，而是属于类的，凡是本类的对象都共享同一份

静态static关键字修饰成员变量

/*
如果一个成员变量使用了static关键字，那么这个变量不再属于自己，二十属于所在的类，多个对象共享同一份数据
*/
public class Student {

    private int id;//学号
    private String name;//姓名
    private int age;//年龄
    static String room;//所在教室
    private static int idCounter = 0;//学号计数器，每当new一个新对象的时候 idCounter++

    public Student() {
        this.id = ++idCounter;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        this.id = ++idCounter;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class Demo {
    public static void main(String[] args) {
        Student student = new Student("abc",18);
        student.room = "101教室";
        System.out.println("姓名："+student.getName()
                +",年龄："+student.getAge()
                +",教室："+student.room
                +",学号："+student.getId());
        Student student1 = new Student("efg",20);
        System.out.println("姓名："+student1.getName()
                +",年龄："+student1.getAge()
                +",教室："+student1.room
                +",学号："+student1.getId());
    }
}
//姓名：abc,年龄：18,教室：101教室,学号：1
//姓名：efg,年龄：20,教室：101教室,学号：2

静态static关键字修饰成员方法

public class MyClass {

    int num;//成员方法
    static int numStatic;//静态变量

    public void method(){
        System.out.println("这是一个成员方法");
        //成员方法可以访问成员变量
        System.out.println(num);
        //成员方法可以访问静态变量
        System.out.println(numStatic);
    }
    public static void methodStatic(){
        System.out.println("这是一个静态方法");
        //静态方法可以访问静态变量
        System.out.println(numStatic);
        //静态方法不能访问非静态变量
        //System.out.println(num);//错误写法
        //静态方法中不能使用this关键字
        //System.out.println(this);//错误写法
    }
}

/*
一旦使用static修饰成员方法，那么这个方法就成了静态方法，静态方法不适于对象，属于类
如果没有static关键字，那么必须首先创建对象然后通过对象才能使用
如果有static关键字，那么不需要创建对象，直接通过类名调用

无论是成员变量还是成员方法，如果有了static都推荐使用类名进行调用
静态变量：类名.静态变量
静态方法：类名.静态方法()

注意：
1、静态不能直接访问非静态
原因：在内存中先有静态内容后有非静态内容
2、静态方法当中不能使用this关键字
原因：this代表当前对象，通过谁调用的方法，谁就是当前对象
*/
public class Demo {
    public static void main(String[] args) {
        MyClass mc = new MyClass();//首先创建对象
        //然后才能使用没有static关键字的内容
        mc.method();

        //对于静态方法来说，可以通过对象名调用，也可以通过类名调用
        mc.methodStatic();//不推荐
        MyClass.methodStatic();//推荐

        //对本类当中的静态方法可以省略类名
        myMethod();//与Demo.myMethod();等效
    }

    public static void myMethod(){
        System.out.println("自己的方法");
    }
}

静态static的内存图

在这里插入图片描述

静态代码块

/*
静态代码块格式：
public class 类名{
	static{
		//
	}
}
特点：当第一次用到本类是，静态代码块执行唯一一次
静态内容总是优先非静态，所以静态代码块比构造方法先执行
静态代码块的典型用途：
用来一次性的堆静态成员变量赋值
*/
public class Demo{
    static{
        System.out.printlm("静态代码块执行");
    }
    public Demo(){
        System.out.printlm("构造方法执行");
    }
}

public class Demo01{
    public static void main(String[] args){
        Person p1 = new Person();
        Person p2 = new Person();
    }
}

//构造方法代码块执行
//构造方法执行
//构造方法执行

数组工具类Arrays

/*
java.util.Arrays是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见的操作

注意：
1、如果是数值，sort默认按照升序从小到大
2、如果是字符串，sort默认安装字母升序
3、如果是自定义类型，那么这个自定义类需要有Comparable或者Comparator接口的支持
*/
public static String toString(数组)//将参数数组变成字符串
public static void sort(数组)//按照默认升序对数组的元素进行排序

数学工具类Math

/*
java.util.Math类是数学相关的工具类，里面提供了大量静态方法，完成与数学运算相关的操作
*/
public static double abs(double num)//获取绝对值
public static double ceil(double num)//向上取整
public static double floor(double num)//向下取整
public static long round(double num)//四舍五入
Math.PI代表近似的圆周率常量

继承

面向对象的三大特征：封装性、继承性、多态性

继承是多态的前提，如果没有继承，就没有多态

继承主要解决的问题就是：共性抽取

继承关系中的特点：

子类可以拥有父类的”内容“
子类还可以拥有自己的”内容“

继承的格式

定义父类的格式（一个普通的类定义）：

public class 父类名称{
    //...
}

定义子类的格式：

public class 子类名称 extends 父类名称{
    //...
}

/*
在继承关系中，“子类就是一个父类”，也就是说，子类也可以被当作父类看待
*/
public class Employee{
    public void method(){
        System.out.println("方法执行！");
    }
}

public class Teacher extends Employee{
    
}

public class Assistant extends Employee{
    
}

public class Demo{
    public static void main(String[] args){
        //创建一个子类对象
        Teacher teacher = new Teacher();
        //Teacher类中什么都没有，但是会继承来自父类的method方法
        teacher.method();//方法执行！
        
        Assistant assistant = new Assistant();
        assistant.method();//方法执行！
    }
}

继承中成员变量的访问特点

在父类的继承关系中，如果成员变量重名，则创建子类对象时，访问有两种方式

直接通过子类对象访问成员变量

等号左边是谁，就优先用谁，没有则向上找(等号左边是指 new 对象的等号左边)
间接通过成员方法访问成员变量

该方法属于谁，就优先用谁，没有则向上找

区分子类方法中重名的三种方法

局部变量：直接写成员变量名

本类的成员变量：this . 成员变量名

父类的成员变量：super . 成员变量名

继承中成员方法的访问特点

在父类的继承关系当中，创建子类对像，访问成员方法的规则

创建的对象是谁，就优先用谁，如果没有就向上找

注意：

无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类的

继承中方法的覆盖重写(Override)

概念：在继承关系中，方法名称一样，参数列表也一样

重写(Override)：方法的名称一样，参数列表也一样

重载(Overload)：方法的名称一样，参数列表不一样

方法的覆盖重写特点：创建的是子类对象，则优先用子类的方法

方法覆盖重写的注意事项：

必须保证父子类之间的方法名相同，参数列表也相同

@Override:写在方法前面，用来检测是不是有效的正确覆盖重写

这个注解就算不写，只要满足要求，也是正确的方法覆盖重写
子类方法的返回值必须小于等于父类方法的返回值范围

java.lang.Object类是所有类的公共最高父类，java.lang.String就是Object的子类
子类方法的权限必须大于等于父类方法的权限修饰符

public > protected > default > private

default不是关键字，是什么都不写，留空

继承中构造方法的访问特点

继承关系中，父子类构造方法的访问特点：

子类构造方法当中有一个默认隐含的 super() 调用，所以一定要先调用的父类构造，后执行子类构造
子类构造可以通过 super 关键字调用父类重载构造
super 的父类构造调用，必须是子类构造方法中的第一个语句，不能一个子类构造调用多次 super 构造

总结：子类必须调用父类的构造方法，不写则赠送一个 super();，写了则用写的指定的 super 调用，super 只能有一个，还必须是第一个

super关键字的三种用法

super 关键字的使用方法有三种：

在子类的成员方法中，访问父类的成员变量
在子类的成员方法中，访问父类的成员方法
在子类的构造方法中，访问父类的构造方法

this关键字的三种用法

super 关键字用来访问父类内容，而this关键字用来访问本类内容，用法也有三种：

在本类成员方法中，访问本类的成员变量
在本类的成员方法中，访问本类的另一个成员方法
在本类的构造方法中，访问本类的另一个构造方法

注意：

在第三种用法当中要注意，this(…) 调用也必须是构造方法的第一个语句，唯一一个
super 和 this 两种构造，不能同时使用

super和this关键字的内存图

在这里插入图片描述

Java继承的三个特点

1、Java语言是单继承的，一个类的直接父类只能有一个

class A{}
class B extends A{}//正确
class C{}
class D extends A,C{}//错误

2、Java语言可以多级继承

class A{}
class B extends A{}//正确
class C extends B{}//正确

3、一个子类的直接父类是唯一的，但是一个父类可以拥有多个子类

class A{}
class B extends A{}//正确
class C extends A{}//正确

掉发阿龙

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
3
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录