Java慕课笔记-01

最新推荐文章于 2023-01-02 21:31:04 发布

法随

最新推荐文章于 2023-01-02 21:31:04 发布

阅读量142

点赞数

分类专栏： Java学习笔记文章标签：字符串继承多态抽象类接口

本文链接：https://blog.csdn.net/Class013/article/details/115403367

版权

Java学习笔记专栏收录该内容

20 篇文章 1 订阅

订阅专栏

字符串

字符串的底层是byte类型的数组。
对于引用数据类型来说，==进行的是地址比较。
双引号直接写的在字符串在常量池当中，new的不在池中。
对字符串内容比较，常用两个方法。

public boolean equals(Object obj):参数可以实任何对象，只有参数是一个字符串并且内容相同才会返回true。
任何对象都能用object进行接收。
equals方法具有对称性，也就是说a.equals(b)和b.equals(a)效果一样。
如果比较双方一个常量一个变量，推荐把常量字符串写在前面。
public boolean equalsIgnoreCase(String str):忽略大小写进行比较

String当中与获取相关的常用方法：

public int lenth();获取字符串中含有的字符个数，拿到字符串长度。
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),包含左边，不包含右边。

String 中与转换相关的常用方法：

public char[] toCharArray();将当前字符串拆分成字符串数组作为返回值。
pubilc byte[] getBytes();获得当前字符串底层的字节数组。
public String replace(CharSequence oldString,CharSequence newSreing),将所有出现的老字符串替换成新的字符串，返回替换之后的结果新字符串。

字符串的分割方法：

1.public String[] split(String regex);按照参数规则，将字符串切分成若干部分。
参数实际上是正则表达式，如果需要使用特殊符号进行切割，需要使用转义字符。

static关键字

如果一个成员变量使用了static关键字，那么这个变量不再属于自己，而是属于所在的类，多个对象共享同一份数据。
一旦使用static修饰成员方法，那么这个方法就成了静态方法，静态方法不属于对象，属于类的。
如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。
对于静态方法，可以通过对象名进行调用，也可以直接通过类名称来调用。推荐使用类名称调用静态方法。

无论是成员变量还是成员方法。如果有了static，都推荐使用类名称调用。
对于本类中的静态方法，可以省略类名称

静态不能直接访问非静态。

原因：因为在内存中，【先】有的静态内容。【后】有的非静态内容。
“先人不知道后人，但是后人知道先人”。

静态方法中不能只用this关键字。

原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。

根据类名称访问静态变量的时候，全程和对象就没有关系。只和类有关系。
静态代码块。当你首次使用本类时，静态代码块执行唯一的一次。

静态内容总是优先于非静态，所以静态代码块优先执行。

静态代码块的典型用途：用来一次性地对静态成员变量进行赋值。

数组工具类Arrays

java.util.Arrays是一个与数组相关的工具类，里面提供了大量的静态方法，用来实现数组常见的操作。
public static String toString(数组)；将参数变成字符串（按照默认格式：[元素1，元素2，…]）。
public static sort(数组)：按照默认的升序对数组元素进行排序。

如果是数值，sort默认按照升序从小到大排列。
如果是字符串，sort默认按照字母升序排列。
如果是自定义的类型，那么这个自定义类需要有Comparable或者Comparator接口的支持。

数学工具类Math

java.util.Math类是数学相关的工具类，里面提供了大量的静态方法，完成数学相关的操作。
public static double abs(double num);获取绝对值。
public static ceil(double num);向上取整。
public static floor(double num);向下取整。
public static long round(double num);四舍五入。

继承

继承是多态的前提。如果没有继承，就没有多态。
继承主要解决的问题：共性抽取。
继承关系的特点：

子类可以拥有父类的内容。
子类还可以拥有自己专有的内容。

在继承关系中，“子类就是一个父类”。也就是说，子类可以被当作父类看待。
在父子继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种方式。

直接通过子类对象访问成员变量。
等号左边是谁，就优先使用谁，没有则向上找。
间接通过成员方法访问成员变量。
方法属于谁，就优先使用谁，没有则向上找。

当局部变量，本类的成员变量，父类的成员变量三者重名时，访问规则：

局部变量：直接使用。 //直接写成员变量名
本类的成员变量：this关键字使用。 //this.成员变量名
父类的成员变量：super关键字访问。 //super.成员变量名

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

创建对象是谁，就优先使用谁，没有则想上找。

重写(Override):在继承关系当中，方法名一样，参数对象一样。

重写(Override)：方法名称一样，参数列表【也一样】。
重载(Overload)：放发名称一样，参数列表【不一样】。

方法覆盖重写注意事项：

必须保证父子类方法的名称相同，参数列表也相同。
@Override：写在方法前面，用来检测是不是有效的正确覆盖重写。
子类方法的返回值必须【小于等于】方法父类的返回值范围。
Object类是所有类的最高父类。
子类方法的权限必须【大于等于】父类方法的权限修饰符。
public > protected > (default) > private
备注：(default)不是关键字default，而是什么都不写，留空。

继承的设计原则：对于已经投入使用的类，尽量不要修改，推荐定义一个新的类，来重复利用其中共性内容，并且添加改动新内容。
继承关系中，父子类构造方法的访问特点。

子类构造方法中有一个默认隐含的【super()】调用。默认调用父类的无参构造。
子类构造可以通过super关键字来调用父类重载构造。
super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。
总结：子类必须调用父类构造方法，不写则赠送super();,写了则写指定的super调用，super只能有一个，还必须是第一个。

super关键字的用法

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

this关键字的关键字用来访问本类的内容

在本类的成员方法中，使用本类的成员变量。
在本类的成员方法中，使用本类的另一个成员方法。
在本类的构造方法中，使用本类的另一个构造方法。
在第三种用法中，this调用必须是第一个语句，也必须是唯一一个。

super和this两种构造调用，不能同时使用。

抽象类

抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结束。
抽象类：抽象方法所在的类必须是抽象类才行，在class之前加上abstract即可。
如何使用抽象类和抽象方法：
1. 不能直接创建new抽象类对象。
2. 必须用一个子类来继承抽象父类。
3. 子类必须覆盖重写抽象父类中的所有抽象方法。【子类去掉抽象方法的abstract关键字，然后补上方法体，大括号】。
4. 创建子类对象进行使用。
注意事项：
1. 抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。
2. 抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。
3. 抽象类中不一定含有抽象方法，但有抽象方法的一定是抽象类。
4. 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。

接口

接口就是一种公共的规范标准。编程中，接口就是多个类的公共规范。接口是一种引用数据类型。

接口的定义格式：

public interface 接口名称{
    	//接口内容
}

接口中定义抽象方法：
1. 接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract
2. 这两个关键字修饰符，可以选择性的省略。
3. 方法的三要素可以随意定义。
接口使用步骤
1. 接口不能直接使用，必须要有一个实现类来实现该接口。
```
	public class 实现类名称 implements 接口名称{
		//
}
```
1. 接口的实现类必须覆盖重写接口中的所有抽象方法。
  实现：去掉abstract关键字，加上方法体，大括号。
2. 创建实现类的对象，进行使用。
注意事项：如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个类自己就必须是抽象类。
从Java 8开始，接口允许定义默认方法。格式：

   public default 返回值类型 方法名称(参数列表){
      方法体
   }

备注：接口当中的默认方法，可以解决接口升级的问题。
接口的默认方法，可以通过接口实现类对象，直接调用。
接口的默认方法，也可以被接口实现类进行覆盖重写。
从JDK 8，接口中允许定义静态方法。格式：

   public static 返回值类型 方法名称(参数列表){
      方法体
   }

提示：就是将abstrcat或者defult换成static即可，带上方法体。

通过接口名称，直接调用其中的静态方法。
从Java 9开始，接口中允许定义私有方法，用来解决多个默认方法之间重复代码块的问题。但是这个共有方法不应该让实现类使用，应该是私有化的。
接口中也可以定义“成员变量”，但是必须使用public static final三个关键字进行修饰。
注意事项：

接口中的常量，可以省略public static final，注意，不写也是这样。
接口中的常量，必须进行赋值，不能不赋值。
接口中的常量名称，使用完全大写的字母，用下划线进行分割。

在Java 9+版本中，接口的内容可以有：

成员变量其实就是常量，格式：

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

注意：
常量必须赋值，而且一旦赋值不能改变。
常量名称必须完全大写，用下划线进行分隔。

接口中最重要的就是抽象方法，格式：

   [piublic] [abstract] 返回值类型 方法名称(参数列表);

注意：实现类必须覆盖重写接口所有的抽象方法，除非实现类是抽象类。

从Java 8 开始，几口允许定义默认方法，格式：

   [pubilc] default 返回值类型 方法名称(参数列表){
      方法体
   }

注意：默认方法也可以被覆盖重写。

从Java 8开始，接口里允许定义静态方法，格式：

   [public] static 返回值类型 方法名称(参数列表){
      方法体
   }

注意：应该通过接口名称进行调用，不能通过实现类的对象调用接口静态方法。

从Java 9开始，接口里允许定义私有方法，格式：

普通私有方法：
   private 返回值类型 方法名称(参数列表){
   方法体；
   }

静态私有方法：

   private static 返回值类型 方法名称(参数列表){
      方法体；
   }

注意：private 的方法只有接口自己才能调用，不能被实现类或者别人调用。

使用接口的时候，需要注意：

接口是没有静态代码块或者构造方法的。
一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。格式：

   public class 类名 implements 接口1,接口2{
      //覆盖重写所有抽象方法
   }

如果实现类所实现的多个接口中，存在重复的抽象方法，那么只需要覆盖重写一次即可。
如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。
如果实现类所实现的多个接口中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。
一个类如果直接父类当中的方法，和接口当中的默认方法，产生了冲突，那么优先使用直接父类当中的方法。

类与类之间是单继承的，直接父类只有一个。
类与接口之间是多继承的，一个类可以实现多个接口。
接口与接口之间是多继承的。
注意事项：

多个父接口当中的抽象方法如果重复，没关系。
多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法覆盖重写，而且需要带着default关键字。

多态

extends继承或者implements的实现，是多态的前提。
代码当中体现多态性，其实就是一句话，父类引用指向子类对象。
格式

   父类名称 对象名 = new 子类名称();
或者
   接口名称 对象名 = new 实现类名称();

访问成员变量的两种方式：
1. 直接通过对象名称访问成员变量：看等号左边是谁，优先用谁，没有则向上找。
2. 间接通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有则向上找。
成员变量：编译看左边，运行还看左边。
成员方法：编译看左边，运行看右边。
对象的向上转型，其实就是多态写法：
1. 父类名称对象名 = new 子类名称();
2. 含义：右侧创建一个子类对象，把它当作父类来看待使用。
3. 注意事项：向上转型一定是安全的。从小范围转向了大范围。
对象的向下转型，其实是一个还原的动作：
1. 父类名称对象名 = new 子类名称();
2. 含义：将父类对象，【还原】成为本来的子类对象。
对象 instanceof 类名称

这将得到一个boolean值结果，也就是判断前面的对象能不能当作后面的类型。

法随

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java慕课笔记-01

字符串字符串的底层是byte类型的数组。对于引用数据类型来说，==进行的是地址比较。双引号直接写的在字符串在常量池当中，new的不在池中。对字符串内容比较，常用两个方法。public boolean equals(Object obj):参数可以实任何对象，只有参数是一个字符串并且内容相同才会返回true。任何对象都能用object进行接收。equals方法具有对称性，也就是说a.equals(b)和b.equals(a)效果一样。如果比较双方一个常量一个变量，推荐把常量字符串写在前
复制链接

扫一扫

专栏目录