Java基础

最新推荐文章于 2023-01-05 17:00:43 发布

Dream答案

最新推荐文章于 2023-01-05 17:00:43 发布

阅读量214

点赞数

分类专栏： Java基础

本文链接：https://blog.csdn.net/Answer0902/article/details/96422806

版权

Java基础专栏收录该内容

5 篇文章 0 订阅

订阅专栏

数据类型：

Java是强类型语言，其支持的类型有：基本类型和引用类型；

基本数据类型	整类型	byte	1个字节（-128~127）
		short	2个字节（- $2^{15}$ ~ $2^{15}$ -1）
		int	4个字节（- $2^{31}$ ~ $2^{31}$ -1）
		long	8个字节（- $2^{63}$ ~ $2^{63}$ -1）
	字符类型	char	2个字节（0~65535）
	浮点类型	float	4个字节
	浮点类型	double	8个字节
	布尔类型	boolean	1位

数组：

初始化：（并不是对数组变量执行初始化，而是在堆内存中创建数组对象，即为该数组对象分配一块连续的内存空间）

静态初始化：初始化时由程序员显示指定每个数组元素的初始值，由系统决定数组长度；
动态初始化：初始化时程序员只指定数组长度，由系统为数组元素分配初始值；

对象：

值传递：当调用方法时，如果传入的数值为基本数据类型（包含String）,形式参数的改变对实际参数不影响；
引用传递：当调用方法时，如果传入的数值为引用数据类型（不包含String）,形式参数的改变对实际参数有影响；

方法重载的要求：

同一个类中方法名相同，参数列表不同（方法返回值类型、修饰符等与重载无关）；

面向对象的三大特征：

封装：将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象内部信息，而是通过该类所提供的方法来实现对内部信息的操作和访问；

继承：重写：“两同两小一大”：方法名、参数列表相同，子类方法返回值类型应比父类方法返回值类型更小或相等，子类方法声明抛出的异常应比父类方法抛出的异常类更小或相等，子类方法的访问权限应比父类方法更大或相等；（覆盖方法和被覆盖方法要么都是类方法，要么都是实例方法）
多态：应用变量有两个类型：编译时类型由声明该变量时使用的类型决定，运行时的类型由实际赋给该变量的对象决定，如果编译时类型和运行时类型不一致就会出现多态；存在条件：继承、重写、父类引用指向子类对象；

多态的转型：

向上转型：多态本身就是向上转型过的过程；
向下转型：一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用类型转为子类引用各类型；
instanceof:用来判断前面的对象是否是后面的类，其子类，实现类的实例，返回值是布尔类型；

初始化块：

执行顺序：静态初始化块->初始化块->构造器->静态方法

包装类：

自动装箱：把一个基本类型变量直接赋给对应的包装类变量；
自动拆箱：把包装类对象直接赋给一个对应的基本类型变量；

Integer i=9;
int i1=i;

基本类型与字符串之间的装换，包装类(除Character)提供了parseXxx(String str)静态方法,用于将特定字符串转换成基本类型变量；String类里提供了多个重载valueOf()方法，用于将基本类型转换成字符串类型；

int num=9;
String str=String.valueOf(num);

String str1="111.3";
float f=Float.parseFloat(str1);

==和equals:

==:若是两个基本类型的变量，且都是数值类型，则只要两个变量的值相等，使用==判断就将返回true;若是两个引用类型的基本变量，必须它们指向同一个对象时，==才会返回true;

equals:用来判断两个引用变量是否相等；

正确的重写equals方法应该满足下列条件：

自反性：对任意x,x.equals(x)一定返回true;
对称性：对任意x和y，如果x.equals(y)返回true,则y.equals(x)也返回true;
传递性：对任意x,y,z,如果有x.equals(y)返回true,y.equals(z)返回true,则x.equals(z)一定返回true；
一致性：对任意x和y，如果对象中用于等价比较的信息没有改变,那么无论调用x.equals(y)多少次，返回的结果都应该保持一致；
对任何不是null的x,x.equals(null)一定返回false;

以下是String的equals方法源码：

public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

但是由于instanceof的特殊性，当前面对象是后面类的实例或者其子类的实例都将返回true,所以实际重写时应用反射去判断，如下：

@Override
    public boolean equals(Object object){
        if(this==object){
            return true;
        }
        if(object!=null&&object.getClass()==Person.class){
            Person personObj=(Person) object;
            if(this.getName().equals(personObj.getName())){
                return true;
            }
        }
        return false;
    }

对象的克隆：

浅拷贝：拷贝对象时仅仅拷贝对象本身（包括对象中的基本变量），而不拷贝对象包含的引用指向的对象，

深拷贝：不仅拷贝对象本身，而且拷贝对象包含的引用指向的所有对象；

package clone;

public class FleetClone {
    public static void main(String[] args) {
        Person person=new Person("person");
        Student student=new Student(person);
        Student student1=(Student) student.clone();
        student1.person.setName("new");
        System.out.println(student.person.getName());
        System.out.println(student1.person.getName());
    }
}
class Person{
    private String name;
    public Person(String name){
        this.name=name;
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
class Student implements Cloneable{
    public Person person;
    public Student(Person person){
        this.person=person;
    }
    public Object clone(){
        Student student=null;
        try {
            student=(Student) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }return student;
    }
}

package clone1;

public class DeeplyClone {
    public static void main(String[] args) {
        Person person=new Person("deeply");
        Student student1=new Student(person);
        Student student2=(Student) student1.clone();
        student2.person.setName("new deeply");
        System.out.println(student1.person.getName());
        System.out.println(student2.person.getName());
    }


}
class Person implements Cloneable{
    private String name;
    public Person(String name){
        this.name=name;
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public Object clone(){
        Person person=null;
        try {
            person=(Person) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }return person;
    }
}
class Student implements Cloneable{
    public Person person;
    public Student(Person person){
        this.person=person;
    }
    public Object clone(){
        Student student=null;
        try {
            student=(Student) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        student.person=(Person) person.clone();//把其它对象的引用也做克隆
        return student;
    }
}

this:指向调用该方法的对象；
super:在子类方法中调用父类中被覆盖的方法；

抽象类：

抽象方法和抽象类必须使用abstract修饰符来定义，有抽象方法的类只能被定义为抽象类，抽象类里可以没有抽象方法；

抽象类和抽象方法的规则如下：

抽象类必须使用abstract修饰，抽象方法也必须使用abstract修饰，抽象方法不能有方法体；
抽象类不能被实例化，无法使用new;
抽象类可以包含属性、方法（普通或者抽象）、构造器、初始化块、内部类、枚举类，抽象类的构造器不能用于创建实例，主要用于被其子类调用；
含有抽象方法的类（包括直接定义了一个抽象方法；继承了一个抽象父类，但没有完全实现父类包含的抽象方法；以及实现了一个接口，但没有完全实现接口包含的抽象方法三种情况）只能被定义为抽象类；

接口：

是抽象方法和常量值的定义集合，一个接口可以继承多个父接口；

接口里可以包含属性（只能是常量）、方法（抽象实例方法）、内部类和枚举类，不包含构造器和初始化块，

接口和抽象类的差别：

接口内只能包含抽象方法，抽象类可以包含普通方法；
接口不能定义静态方法，抽象类可以；
接口只能定义静态常量属性，不能定义普通常量属性；抽象类则都可以；
接口不包含构造器；抽象类可以包含构造器，但只是用来让其子类调用构造器完成抽象类的初始化操作；
接口不包含初始化块，但抽象类包含初始化块，
类可以实现多接口，但只能继承一个抽象类；
接口可以多继承；

内部类：

一个类放在另一个类的内部定义，这个定义在其他类内部的类即为内部类；

内部类的作用：

内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类；
内部类成员可以访问外部类的私有数据；
匿名内部类适合用于创建仅需要一次使用的类；

匿名内部类：

匿名内部类不能是抽象类，系统在创建匿名内部类得到时候，会立即创建匿名内部类的对象；
匿名内部类不能定义构造器，因为匿名内部类无类名；

常用类：

Object类：

是所用类、数组、枚举类的父类，Java允许把所有任何类型的对象赋给Object类型的变量，当定义一个类时没有使用extends关键字为它显示指定父类，则该类默认继承Object类；

提供常用的方法：

boolean equals(Object obj):判断指定对象与该对象是否相等；
protected void finalize():当系统中没有引用变量引用到该对象时，垃圾回收器调用此方法来清理该对象的资源；
Class<?> getClass():该方法返回该对象的运行时类；
int hashCode:返回该对象的hashCode值；
String toString():Object的该方法返回“运行时类名@十六进制hashCode值”格式的字符串；
除此之外还包括wait()、notify()、notifyAll()来控制线程的暂停和运行；

String、StringBuilder、StringBuffer区别:

速度：StringBuilder》StringBuffer》String；
StringBuilder/StringBuffer是字符串变量，是可以改变的对象，实际是在一个对象上操作，String是创建一些对象；
StringBuilder：线程不安全；StringBuffer：线程安全；

BigDecimal类：

因为float、double容易引起精度丢失，为了精确计算浮点数，Java提供了BigDecimal类；创建该对象时一般采用如下两种方式:

BigDecimal bigDecimal=new BigDecimal("1.2");
BigDecimal bigDecimal2=BigDecimal.valueOf(1.2);

Math类：

字段摘要
`static double`	`E` 比任何其他值都更接近 e（即自然对数的底数）的 `double` 值。
`static double`	`PI` 比任何其他值都更接近 pi（即圆的周长与直径之比）的 `double` 值。

方法摘要
`static double`	`abs(double a)` 返回 `double` 值的绝对值。
`static float`	`abs(float a)` 返回 `float` 值的绝对值。
`static int`	`abs(int a)` 返回 `int` 值的绝对值。
`static long`	`abs(long a)` 返回 `long` 值的绝对值。
`static double`	`acos(double a)` 返回一个值的反余弦；返回的角度范围在 0.0 到 pi 之间。
`static double`	`asin(double a)` 返回一个值的反正弦；返回的角度范围在 -pi/2 到 pi/2 之间。
`static double`	`atan(double a)` 返回一个值的反正切；返回的角度范围在 -pi/2 到 pi/2 之间。
`static double`	`atan2(double y, double x)` 将矩形坐标 (`x`, `y`) 转换成极坐标 (r, theta)，返回所得角 theta。
`static double`	`cbrt(double a)` 返回 `double` 值的立方根。
`static double`	`ceil(double a)` 返回最小的（最接近负无穷大）`double` 值，该值大于等于参数，并等于某个整数。
`static double`	`copySign(double magnitude, double sign)` 返回带有第二个浮点参数符号的第一个浮点参数。
`static float`	`copySign(float magnitude, float sign)` 返回带有第二个浮点参数符号的第一个浮点参数。
`static double`	`cos(double a)` 返回角的三角余弦。
`static double`	`cosh(double x)` 返回 `double` 值的双曲线余弦。
`static double`	`exp(double a)` 返回欧拉数 e 的 `double` 次幂的值。
`static double`	`expm1(double x)` 返回 ex -1。
`static double`	`floor(double a)` 返回最大的（最接近正无穷大）`double` 值，该值小于等于参数，并等于某个整数。
`static int`	`getExponent(double d)` 返回 `double` 表示形式中使用的无偏指数。
`static int`	`getExponent(float f)` 返回 `float` 表示形式中使用的无偏指数。
`static double`	`hypot(double x, double y)` 返回 sqrt(x2 +y2)，没有中间溢出或下溢。
`static double`	`IEEEremainder(double f1, double f2)` 按照 IEEE 754 标准的规定，对两个参数进行余数运算。
`static double`	`log(double a)` 返回 `double` 值的自然对数（底数是 e）。
`static double`	`log10(double a)` 返回 `double` 值的底数为 10 的对数。
`static double`	`log1p(double x)` 返回参数与 1 之和的自然对数。
`static double`	`max(double a, double b)` 返回两个 `double` 值中较大的一个。
`static float`	`max(float a, float b)` 返回两个 `float` 值中较大的一个。
`static int`	`max(int a, int b)` 返回两个 `int` 值中较大的一个。
`static long`	`max(long a, long b)` 返回两个 `long` 值中较大的一个。
`static double`	`min(double a, double b)` 返回两个 `double` 值中较小的一个。
`static float`	`min(float a, float b)` 返回两个 `float` 值中较小的一个。
`static int`	`min(int a, int b)` 返回两个 `int` 值中较小的一个。
`static long`	`min(long a, long b)` 返回两个 `long` 值中较小的一个。
`static double`	`nextAfter(double start, double direction)` 返回第一个参数和第二个参数之间与第一个参数相邻的浮点数。
`static float`	`nextAfter(float start, double direction)` 返回第一个参数和第二个参数之间与第一个参数相邻的浮点数。
`static double`	`nextUp(double d)` 返回 `d` 和正无穷大之间与 `d` 相邻的浮点值。
`static float`	`nextUp(float f)` 返回 `f` 和正无穷大之间与 `f` 相邻的浮点值。
`static double`	`pow(double a, double b)` 返回第一个参数的第二个参数次幂的值。
`static double`	`random()` 返回带正号的 `double` 值，该值大于等于 `0.0` 且小于 `1.0`。
`static double`	`rint(double a)` 返回最接近参数并等于某一整数的 `double` 值。
`static long`	`round(double a)` 返回最接近参数的 `long`。
`static int`	`round(float a)` 返回最接近参数的 `int`。
`static double`	`scalb(double d, int scaleFactor)` 返回 `d` × 2`scaleFactor`，其舍入方式如同将一个正确舍入的浮点值乘以 double 值集合中的一个值。
`static float`	`scalb(float f, int scaleFactor)` 返回 `f` × 2`scaleFactor`，其舍入方式如同将一个正确舍入的浮点值乘以 float 值集合中的一个值。
`static double`	`signum(double d)` 返回参数的符号函数；如果参数为 0，则返回 0；如果参数大于 0，则返回 1.0；如果参数小于 0，则返回 -1.0。
`static float`	`signum(float f)` 返回参数的符号函数；如果参数为 0，则返回 0；如果参数大于 0，则返回 1.0；如果参数小于 0，则返回 -1.0。
`static double`	`sin(double a)` 返回角的三角正弦。
`static double`	`sinh(double x)` 返回 `double` 值的双曲线正弦。
`static double`	`sqrt(double a)` 返回正确舍入的 `double` 值的正平方根。
`static double`	`tan(double a)` 返回角的三角正切。
`static double`	`tanh(double x)` 返回 `double` 值的双曲线余弦。
`static double`	`toDegrees(double angrad)` 将用弧度表示的角转换为近似相等的用角度表示的角。
`static double`	`toRadians(double angdeg)` 将用角度表示的角转换为近似相等的用弧度表示的角。
`static double`	`ulp(double d)` 返回参数的 ulp 大小。
`static float`	`ulp(float f)` 返回参数的 ulp 大小。

从类 java.lang.Object 继承的方法
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Random类：

Random类专门用于生成一个伪随机数，

构造方法摘要
`Random()` 创建一个新的随机数生成器。
`Random(long seed)` 使用单个 `long` 种子创建一个新的随机数生成器。

方法摘要
`protected int`	`next(int bits)` 生成下一个伪随机数。
`boolean`	`nextBoolean()` 返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 `boolean` 值。
`void`	`nextBytes(byte[] bytes)` 生成随机字节并将其置于用户提供的 byte 数组中。
`double`	`nextDouble()` 返回下一个伪随机数，它是取自此随机数生成器序列的、在 `0.0` 和 `1.0` 之间均匀分布的 `double` 值。
`float`	`nextFloat()` 返回下一个伪随机数，它是取自此随机数生成器序列的、在 `0.0` 和 `1.0` 之间均匀分布的 `float` 值。
`double`	`nextGaussian()` 返回下一个伪随机数，它是取自此随机数生成器序列的、呈高斯（“正态”）分布的 `double` 值，其平均值是 `0.0`，标准差是 `1.0`。
`int`	`nextInt()` 返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 `int` 值。
`int`	`nextInt(int n)` 返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值（不包括）之间均匀分布的 `int` 值。
`long`	`nextLong()` 返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 `long` 值。
`void`	`setSeed(long seed)` 使用单个 `long` 种子设置此随机数生成器的种子。

正则表达式：

方法摘要
`Matcher`	`appendReplacement(StringBuffer sb, String replacement)` 实现非终端添加和替换步骤。
`StringBuffer`	`appendTail(StringBuffer sb)` 实现终端添加和替换步骤。
`int`	`end()` 返回最后匹配字符之后的偏移量。
`int`	`end(int group)` 返回在以前的匹配操作期间，由给定组所捕获子序列的最后字符之后的偏移量。
`boolean`	`find()` 尝试查找与该模式匹配的输入序列的下一个子序列。
`boolean`	`find(int start)` 重置此匹配器，然后尝试查找匹配该模式、从指定索引开始的输入序列的下一个子序列。
`String`	`group()` 返回由以前匹配操作所匹配的输入子序列。
`String`	`group(int group)` 返回在以前匹配操作期间由给定组捕获的输入子序列。
`int`	`groupCount()` 返回此匹配器模式中的捕获组数。
`boolean`	`hasAnchoringBounds()` 查询此匹配器区域界限的定位。
`boolean`	`hasTransparentBounds()` 查询此匹配器区域边界的透明度。
`boolean`	`hitEnd()` 如果匹配器执行的最后匹配操作中搜索引擎遇到输入结尾，则返回 true。
`boolean`	`lookingAt()` 尝试将从区域开头开始的输入序列与该模式匹配。
`boolean`	`matches()` 尝试将整个区域与模式匹配。
`Pattern`	`pattern()` 返回由此匹配器解释的模式。
`static String`	`quoteReplacement(String s)` 返回指定 `String` 的字面值替换 `String`。
`Matcher`	`region(int start, int end)` 设置此匹配器的区域限制。
`int`	`regionEnd()` 报告此匹配器区域的结束索引（不包括）。
`int`	`regionStart()` 报告此匹配器区域的开始索引。
`String`	`replaceAll(String replacement)` 替换模式与给定替换字符串相匹配的输入序列的每个子序列。
`String`	`replaceFirst(String replacement)` 替换模式与给定替换字符串匹配的输入序列的第一个子序列。
`boolean`	`requireEnd()` 如果很多输入都可以将正匹配更改为负匹配，则返回 true。
`Matcher`	`reset()` 重置匹配器。
`Matcher`	`reset(CharSequence input)` 重置此具有新输入序列的匹配器。
`int`	`start()` 返回以前匹配的初始索引。
`int`	`start(int group)` 返回在以前的匹配操作期间，由给定组所捕获的子序列的初始索引。
`MatchResult`	`toMatchResult()` 作为 `MatchResult` 返回此匹配器的匹配状态。
`String`	`toString()` 返回匹配器的字符串表示形式。
`Matcher`	`useAnchoringBounds(boolean b)` 设置匹配器区域界限的定位。
`Matcher`	`usePattern(Pattern newPattern)` 更改此 Matcher 用于查找匹配项的 Pattern。
`Matcher`	`useTransparentBounds(boolean b)` 设置此匹配器区域边界的透明度。

@Test
    public void t1(){
        //Pattern pattern=Pattern.compile("[b]");
        Matcher matcher=Pattern.compile("[b]").matcher("aaab");
        while (matcher.find()){
            System.out.println(matcher.group());
        }
    }