js1-1-2-CSDN博客

本文链接：https://blog.csdn.net/m0_74348480/article/details/129805081

arraylist

在这里插入图片描述

116

在这里插入图片描述

static-静态变量

private String name;
private int age;
private String gender;
public static String teacherName;

被static修饰的成员变量，叫做静态变量
特点:
被该类所有对象共享
调用方式:
类名调用（推荐)
对象名调用

静态变量是随着类的加载而加载的，优先于对象出现的
不属于对象，属于类

static-静态方法

被static修饰的成员方法，叫做静态方法
特点:
多用在测试类和工具类中Javabean类中很少会用
调用方式:
类名调用（推荐)
对象名调用

Javabean类
用来描述一类事物的类。比如，Student，Teacher，Dog,Cat等
测试类
用来检查其他类是否书写正确，带有main方法的类，是程序的入口
工具类
不是用来描述一类事物的，而是帮我们做一些事情的类。

public class ArrUtil {
private Arrutil(){}
public static int getMax (...){..}
public static int getMin(...){...}
public static int getsum (..){...}
public static int getAvg(...){...}
}

静态方法中没有this关键字
静态方法中，只能访问静态。
非静态方法可以访问所有。

继承的概述

对象代表什么，就得封装对应的数据，并提供数据对应的行为

Java中提供一个关键字extends，用这个关键字，我们可以让一个类和另一个类建立起继承关系。
public class student extends Person { }
Student称为子类（派生类), Person称为父类(基类或超类)。

继承的特点

Java只支持单继承，不支持多继承，但支持多层继承。
Java不支持多继承、但是支持多层继承。
每一个类都直接或者间接的继承于Object

子类到底能继承父类中的哪些内容?

构造方法非私有不能 private不能（都不能）
成员变量非私有能 private能（都能）
成员方法非私有能 private不能

继承中:构造方法的访问特点
父类中的构造方法不会被子类继承。
子类中所有的构造方法默认先访问父类中的无参构造，再执行自己。
为什么?

子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据。
子类初始化之前，一定要调用父类构造方法先完成父类数据空间的初始化。
怎么调用父类构造方法的?
子类构造方法的第一行语句默认都是: super()，不写也存在，且必须在第一行。

1．继承中构造方法的访问特点是什么?

子类不能继承父类的构造方法，但是可以通过super调用
子类构造方法的第一行，有一个默认的super();
默认先访问父类中无参的构造方法，再执行自己。
如果想要方法文父类有参构造，必须手动书写。

this、super使用总结

this:理解为一个变量，表示当前方法调用者的地址值;
super:代表父类存储空间。

在这里插入图片描述

多态

什么是多态?
同类型的对象，表现出的不同形态。
多态的表现形式
父类类型对象名称=子类对象;

多态的前提
有继承关系
有父类引用指向子类对象
有方法重写
Fu f = new zi ( ) ;

多态的好处?
使用父类型作为参数，可以接收所有子类对象，
体现多态的扩展性与便利。

多态调用成员的特点

变量调用:编译看左边，运行也看左边。
方法调用:编译看左边，运行看右边。

多态的优势

●在多态形式下，右边对象可以实现解耦合，便于扩展和维护。

Person p =new student ();
p.work();//业务逻辑发生改变时，后续代码无需修改

定义方法的时候，使用父类型作为参数，可以接收所有子类对象，体现多态的扩展性与便利。

多态的弊端
不能调用子类的特有功能

报错的原因?
当调用成员方法的时候，编译看左边，运行看右边
那么在编译的时候会先检查左边的父类中有没有这个方法，如果没有直接报错。
a. lookHome();

新特性
先判断a是否为Dog类型，如果是，则强转成Dog类型，转换之后变量名为d如果不是，则不强转，结果直接是false

if(a instanceof Dog d){
//Dog d = (Dog)a;
d .lookHome( );
}else if(a instanceof Cat c){
//cat c = (cat) a;
c.catchMouse();
}else{
system.out. println("没有这个类型，无法转换");
)

包和final

●包名的规则:公司域名反写＋包的作用，需要全部英文小写，见名知意。com.itheima.domain

package com.itheima.domain;
public class student {
私有化成员变量
构造方法
成员方法
}

使用其他类时，需要使用全类名。

public class Test {
public static void main(String[ ] args) {
lcom.itheima. domain. students=newcom.itheima. domain. Student();
}
}

import简写版

import com.itheima.domain.Student;
public class Test {
public static void main(string[  ] args) {
student s = new student();
}
}

使用同一个包中的类时，不需要导包。
使用java.lang包中的类时，不需要导包。
其他情况都需要导包
如果同时使用两个包中的同名类，需要用全类名。

Final不得复写

public final void show(){
system.out.print1n("父类的show方法");
}

final修饰方法:
表明该方法是最终方法，不能被重写
final修饰类:
表明该类是最终类，不能被继承
final修饰变量:
叫做常量，只能被赋值一次

final 修改基本数据类型:记录的值不能发生改变
final修饰引用数据类型:记录的地址值不能发生改变，内部的属性值还是可以改变的

-权限修饰符和代码块

在这里插入图片描述
private、私房钱，只能自己用
protected受保护的
默认只能本包中能用
public公共的

实际开发中，一般只用private和public

成员变量私有
方法公开
特例:如果方法中的代码是抽取其他方法中共性代码，这个方法一般也私有。

局部代码块

构造代码块:
1.写在成员位置的代码块
2.作用:可以把多个构造方法中重复的代码抽取出来
3.执行时机:我们在创建本类对象的时候会先执行构代码块再执行构造方法

静态代码块

格式:static{}
特点:需要通过static关键字修饰，随着类的加载而加载，并且自动触发、只执行一次使用场景:在类加载的时候，做一些数据初始化的时候使用。

1．代码块的分类:
局部代码块，构造代码块，静态代码块
2．局部代码块的作用
提前结束变量的生命周期（已淘汰)
3．构造代码块的作用
抽取构造方法中的重复代码（不够灵活)
4.静态代码块的作用
数据的初始化（重点)

抽象方法

抽象方法:将共性的行为（方法）抽取到父类之后。
由于每一个子类执行的内容是不一样，所以，在父类中不能确定具体的方法体。该方法就可以定义为抽象方法。

抽象类:如果一个类中存在抽象方法，那么该类就必须声明为抽象类

抽象类和抽象方法的注意事项

抽象类不能实例化
抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
可以有构造方法
抽象类的子类
- 要么重写抽象类中的所有抽象方法
- 要么是抽象类

1．抽象类的作用是什么样的?
抽取共性时，无法确定方法体，就把方法定义为抽象的。强制让子类按照某种格式重写。
抽象方法所在的类，必须是抽象类。
2.抽象类和抽象方法的格式?
public abstract返回值类型方法名(参数列表);
public abstract class类名{}
3．继承抽象类有哪些要注意?
要么重写抽象类中的所有抽象方法
要么是抽象类

接口的定义和使用

接口用关键字interface来定义
public interface接口名{}
接口不能实例化

接口和类之间是实现关系，通过implements关键字表示·
public class类名implements接口名{}
接口的子类（实现类)

要么重写接口中的所有抽象方法
要么是抽象类

注意1:接口和类的实现关系，可以单实现，也可以多实现。
public class类名implements接口名1，接口名2{}
注意2:实现类还可以在继承一个类的同时实现多个接口。
public class类名extends 父implements接口名1，接口名2{}

接口中成员的特点

成员变量
只能是常量
默认修饰符:public static final

构造方法
没有

成员方法

只能是抽象方法
默认修饰符: public abstract

JDK7以前:接口中只能定义抽象方法。

接口和类之间的关系

类和类的关系
继承关系，只能单继承，不能多继承，但是可以多层继承
类和接口的关系
实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
接口和接口的关系
继承关系，可以单继承，也可以多继承

JDK8以后接口中新增的方法

允许在接口中定义默认方法，需要使用关键字default修饰
作用:解决接口升级的问题

接口中默认方法的定义格式:
格式:public default 返回值类型方法名(参数列表){ }
范例: public default void show(){ }

接口中默认方法的注意事项:
默认方法不是抽象方法，所以不强制被重写。但是如果被重写，重写的时候去掉default关键字public可以省略，default不能省略

如果实现了多个接口，多个接口中存在相同名字的默认方法，子类就必须对该方法进行重写

接口中默认方法的定义格式:

格式: public default返回值类型方法名(参数列表){}
接口中默认方法的注意事项:
1.默认方法不是抽象方法，所以不强制被重写。但是如果被重写，重写的时候去掉default关键字2.public可以省略，default不能省略
3.如果实现了多个接口，多个接口中存在相同名字的默认方法，子类就必须对该方法进行重写*/

public abstract void method( );
public default void show( ){
system.out.println("接口中的默认方法---- show" );

JDK8以后接口中新增的方法

允许在接口中定义定义静态方法，需要用static修饰

接口中静态方法的定义格式:
格式:public static返回值类型方法名(参数列表){}
范例:public static void show(){ }

接口中静态方法的注意事项:
静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
public可以省略, static不能省略

JDK9新增的方法

接口中私有方法的定义格式:

格式1: private枣回值类型方法名(参数列表){}o
范例1: private vpid show(){ }

格式2: private static返回值类型方法名(参数列表){}o

范例2: private static void method(){ }
在这里插入图片描述
1.当一个接口中抽象方法过多，但是我只要使用其中部分的
时候，就可以适配器设计模式
2.书写步骤:
编写中间类XXXAdapter，实现对应的接口对接口中的抽象方法进行空实现
让真正的实现类继承中间类，并重写需要用的方法为了避免其他类创建适配器类的对象，中间的适配器类用abstract进行修饰

什么是内部类?

在一个类的里面，再定义一个类。
举例:在A类的内部定义B类，B类就被称为内部类

public class outer{
public class Inner {
}
}

public class Test {
外部其他类
public static void main(String[] args) {
}
}

什么时候用到内部类?
B类表示的事物是A类的一部分，且B单独存在没有意义。比如:汽车的发动机，ArrayList的迭代器，人的心脏等等

在这里插入图片描述

获取成员内部类对象
方式一:
在外部类中编写方法，对外提供内部类的对象。
方式二:
直接创建格式:外部类名.内部类名对象名=外部类对象.内部类对象;

获取成员内部类对象的两种方式:
方式一:外部类编写方法，对外提供内部类对象方式二:直接创建
格式:外部类名.内部类名对象名=外部类对象.内部类对象;
范例:outer.Inner oi = new outer( ).new Inner();

public Inner getInstance( ){
return new Inner();
}

例子：

package com.itheima.a03innerclassdemo3 ;

public class outer {
private int a = 10;

class Inner {
private int a = 20;

public void show() {
int a = 30;
system.out.println(a); // 30
system.out.println(this.a); //20
system.out.println(Outer.this.a); //10
}
}
}

外部类成员变量和内部类成员变量重名时，在内部类如何访问?
system.out.printin(outer.this.变量名);

public class outer {
int a = 10;
static int b = 20;
//静态内部类
static class Inner {
public void show1(){
outer o = new outer( );
system.out.println(o.a) ;
system.out.println(b );
}
public static void show2( ){
// System.out.println("静态的方法被调用了");
outer o = new outer();
system.out.println(o.a);
system.out.print1n(b );
}
}
}