javase随想2

匿名对象（只能使用唯一一次，下次使用只能再创建一次，如果有一个对象，确定只使用一次，则可以使用匿名对象）

非匿名对象：类 类名 = new 类（）；

            类名.name = “sss”

New Person().name = “sss“；

 

 

根据已经设定的类，创建对象

Person9 arr1 = new Person9[3];

 

泛型只能说引用类型，不能是基本类型

如果想要使用基本类型，必须使用基本类型里的包装类

包装类都在Java.lang包下

 

 

对于ArrayList集合来说，直接打印得到的不是地址值，而是内容[]

 

boolean success = list.add("ss");

用boolea类型的success接收添加的返回值

添加add

查看get，索引从0开始

删除

 

 

String：

字符串效果上是char[]字符数组，底层原理是byte[]字节数组

 

字符串常量池（在堆里）：程序当中直接写上的双引号字符串，就在字符串常量池

对于基本类型，==是进行数值的比较

对于引用类型，==是进行地址值的比较

Str.equals()是进行内容比较

 

Equals具有对称性，但是如果是一个常量一个变量，建议把常量放在前面

直接new不进池子，直接在堆

 

indexOf

String str= “hello“；

Str.IndexOf(“llo”);

 

Substring:截取

 

注！！！字符串不可任意改变，每次运行完成后产生的新字符串都是派生出来的新字符串，原字符串不受改变

 

任何对象都可以通过object接受

//此处的字符串仍然没有改变，只是改变了地址值

String string1 = "hello";
System.out.println(string1);
string1 = "java";
System.out.println(string1);

 

 

Split是正则表达式，无法切割英文句点.

需要写成\\.

 

Static 关键字内容属于类，凡是本类的对象，都共享同一份

 

Static修饰的成员方法，就成为了静态方法，静态方法不属于对象，属于类

没有static修饰，需要先创建对象，再使用

有static修饰，可以直接使用类名.方法

 

静态不能直接访问非静态

方法            成员变量

内存中先有静态内容，后有非静态内容

先人（静态）不知道后人（非），后人（非）知道先人（静态）。

静态方法不能使用this（this代表当前对象，通过谁调用，谁就是当前对象）

 

静态代码块比构造方法先执行；

静态代码块用来对静态成员变量进行一次性的赋值

Arrays.toString 用来将参数数组变成字符串。

.sort是对数组从小到大进行排序。

打印的时候记得System.out.println(Arrays.toString(array1));

排序想数组，如果是字符串则需要toCharArray();

Forr是倒序排列

 

 

Math库

Ceil向上取整

floor向下取整

long round四舍五入

 

继承：：：共性抽取

 

员工包括讲师助教（共同抽取姓名工号（都有点东西））

 

父类、子类

 

子类拥有父类的内容

子类可以有自己的内容

 

如果子父类继承对象中，成员变量名重名，子父类里都有int num = 10；

则看等号，等号左边是谁就优先用谁。没有则向上找；

 

父类不去找子类，都是向上找父。

 

重写，在继承关系中，方法名称一样，参数列表一样。

重载，方法一样，参数列表不一样

 

子类方法的返回值必须小于等于父类方法的返回值范围

 

子类方法的权限必须大于等于父类方法的权限修饰符

Public>protected>default(留空)>private

 

 

先继承父类的功能，再在子类中添加功能

 

子类构造方法（无参）中有一个默认隐含的super（）构造方法

所以先调用父类的构造方法，再执行子类的构造方法

如果有参数，则需要加上super（）；括号里面写上参数

 

只有子类构造方法，才能调用父类构造方法

有参无参只能调用一个，不可调用多次super构造

 

总结：子类必须调用父类构造方法，不写就赠送super（）；写了则用写定的super（）；调用，super只能有一个，还必须是第一个；都必须是调用的第一个语句Super和this两种构造调用，不能同时使用

 

 

Java是单继承，只能有一个直接父类

可以多级继承

 

子类就是一个父类

 

抽象方法所在的类必须是抽象类

 

抽象类不可直接new对象

子类必须重写父类的所有抽象方法，（覆盖重写，子类去掉抽象方法的abstract关键字，然后补上大括号）

如果不，则需要子类也是一个抽象类

 

 

抽象父类构造方法只能通过子类的构造方法执行，不能创造对象。（子类构造方法里赠送的super）

 

一个类不一定含有抽象方法，只要保证抽象方法所在的类是抽象类即可

这样没有抽象方法的抽象类，也不能直接创建对象

 

接口就是公共的规范标准

只要符合标准就可以通用

接口是多个列的公共规范
接口是一种引用数据类型，最重要的内容就是其中的抽象方法
定义一个接口
public interface
接口包括：常量，抽象方法，默认方法，静态方法，私有方法

 

接口定义抽象方法：
public abstract 返回值类型 方法名称（参数列表）；
注意：接口中的抽象方法，修饰符必须是两个固定的关键字：public abstract
但是这两个关键子修饰符可以选择性的省略

 

默认方法会被实现类继承下去，调用抽象类，如果实现类中没有，会向上找接口。

 

Default默认方法：public default void methodDefault

原接口里的方法都需要通过实现类将抽象方法重写进行使用

用接口default修饰后可以直接使用，或者被实现类覆盖重写

使用类里直接创建对象，再用对象.default方法

 

static不能通过接口实现类的对象来调用接口当中的静态方法

正确方法：接口名.静态方法（）；

直接通过接口名调用静态方法

 

当需要抽取一个公共方法，用来解决两个默认方法之间重复代码的问题

但是这个共有方法不应该让实现类使用而是应该私有化

Java9允许定义私有方法

普通私有化，解决多个默认方法之间的重复代码问题

静态私有化，解决多个静态方法之间重复代码问题

 

接口里的常量一旦被赋值，则不可被改变，public static final修饰（public static final可以忽略，但是不影响其作用），接口里的常量必须赋值。

 

接口中常量的名称使用完全大写的字母，用下划线进行分割

 

接口没有静态代码块或者构造方法

一个类可以有多个接口

继承优先于接口

 

接口的继承，如果多个父接口里的抽象方法冲突没问题，如果是默认方法冲突，则必须进行默认方法的重写，且必须带有default

 

多态：父类引用指向子类对象

父类名称 对象名 = new 子类名称（）；

接口名称 对象名 = new 实现类名称（）；

成员方法new的是谁，多态后运行的就是谁

 

左边接口，右边实现类也是多态

 

左父右子就是多态

 

多态无法使用子类的特有内容

 

成员变量：

直接通过对象名称访问成员变量，出现父子类有相同的成员变量，看等号左边是谁，左边是谁就优先调用的是谁的成员方法，没有就向上找

成员变量不能覆盖重写

间接通过成员方法访问成员变量，看该方法属于谁，优先用谁，没有则向上找。

直接访问看等左，间接访问看类属

编译看左边，运行还看左边

 

成员方法：

Fu obj = new Zi();

编译看左，运行看右（调用的时候这个类必须父类子类都有，编译的时候，看左边的类里面有没有用到的方法，如果有，则不报错）

编译成功，运行的时候看结果需要看右边。

 

Fu obj = new Zi();

向上转型为父类则无法调用子类特有方法（只能调用父类的方法）

用向下转型（还原）

子类名称 对象名 = （子类名称）父类对象；

将父类对象还原为本来的子类对象；

 

向下转型时，使用instanceof判断原来的（向上转型时）子类是不是某个子类（返回的是boolean值）

If（animal instanceof Dog）{

Dog dog = （Dog）animal；

dog.方法

}

If（animal instanceof Cat）{

Cat cat= （Cat）animal；

cat.方法

}

 

 

Final类没有子类（太监类）但是可以有父类

其中所有的成员方法都无法进行覆盖重写

 

Final方法不可被覆盖重写

Abstract和final不可同时使用，（注：抽象方法没有方法体，抽象方法所在类必须为抽象类）

 

Final修饰的局部变量，这个变量数据不可改变；引用类型的地址值不可改变（可以使用get，set方法改变，但是不可使用new重设地址值）

 

 

成员变量具有默认值，（Person类里的get，set，有参构造都是赋予默认值）

使用final之后必须手动赋值（初始值为null），对于final修饰的成员变量，要么直接赋值，要么使用构造方法赋值，选一个

1. Private final String name=“啊啊“；
2. 在无参构造里写name=“啊啊“；然后把set方法删除

 

保证所有重载的构造方法都最终会对final成员变量赋值

 

 

 

成员内部类

局部内部类（匿名内部类）

 

内用外可以随意访问外部类的方法，外用内需要有内部类对象

命名格式：外部类$内部类.class(外部显示)

 

如何使用成员内部类

间接方法：

类名称 对象名 = new 类名称

直接方法：

公式  

（一般是：类名称 对象名 = new 类名称；）

外部类名称 . 内部类名称 对象名 = new 外部类名称（） . new 内部类名称（）；

外 . 内

 

间接：对象创建在外部类，，之后在应用类里面直接通过建立外部类对象. 外部类方法就可以调用

直接：外部类名称 . 内部类名称 对象名 = new 外部类名称（） . new 内部类名称（）；

直接用对象名 . 内部类方法

 

 

内部类方法想要访问外部类变量：需要使用外部类名 . this . 变量名

 

写在方法里的是局部内部类，权限修饰符什么都不加

成员内部类的权限修饰符：public protect default private

外部类只有public default

 

 

匿名内部类(省略了实现类)

接口的实现类（或者是父类的子类）只需要使用唯一一次

那么这种情况下就可以省略该类的定义（不写实现类），改为使用匿名内部类

 

New 接口名称（）{

}

 

格式

接口名称 对象名称 = new 接口名称（）{

覆盖重写所有抽象方法

}；

 

匿名内部类是省略了实现类、子类名称，但是只能使用一次

调用匿名内部类省略对象名称，也是匿名对象

New +接口名称（）{

 

Public void method1(){

}

}.method1()

 

如果想要使用多次，则不要使用匿名

 

 

 

看一个类是否重写了toString ，直接打印这个类的对象即可，如果没有重写toString方法，那么打印的时对象的地址值。