当前位置：首页 > news >正文

java基础总结

news 2025/8/19 9:46:16

一静态

1.1 静态字段

静态字段就是将字段定义为static的字段，类的所有实例共享一个静态字段。
静态字段属于类，而不属于任何单个对象。而对于非静态的实例字段，每个对象都有自己的一个副本。
在这里插入图片描述

public class Employee {public static int nextId = 1;public static int getNextId() {//静态方法访问静态常量return nextId;}
}

1.2 静态常量

静态变量使用较少，静态常量使用较多
在这里插入图片描述
由于PI是静态的，所以在我们的程序中，可以使用Math.PI来访问这个值。但是如果PI不是静态的话（PI就是Math类的实例字段），只能使用new Math()一个对象出来后再去访问这个PI了，并且每个对象都有PI的一个副本。

静态字段可以不赋初始值，不赋初始值的话，以后只要有一个地方给这个静态字段赋值了，则后边所有获取这个字段的地方都能获取到这个值了。

静态变量特点：

被该类所有对象共享。
不属于对象，而是属于类
随着类的加载就加载了，优先于对象存在

调用方式有两种：

类名.字段名（推荐）
对象名.字段名

静态字段存在静态区里（堆和方法区是共享的），普通字段跟着对象存在堆里（每个对象会在堆里开辟自己的空间）。静态区里的内容是共享的。

jdk8之前静态区在方法区里，jdk8之后，静态区在堆里了。

静态变量是优先于对象而存在的，即静态变量时随着类的加载而加载的（优先于对象出现）。

1.3 静态方法

静态方法是不在对象上执行的方法，该方法不属于任何对象。例如，Math 类的 pow 方法就是一个静态方法。表达式Math.pow(x， a)会计算幂 xa。在完成计算时，它并不属于任何 Math 对象。换句话说，它没有隐式参数。

特点：

多用在测试类和工具类里
JavaBean类里很少使用

工具类里，构造方法都私有化，因为没有必要让外界实例化工具类的对象，实例化对象没有意义。且工具类里的方法都定义为静态的，方便调用。

可以认为静态方法是没有 this 参数的方法(在一个非静态的方法中，this 参数指示这个方法的隐式参数)。

静态方法不能访问实例字段，因为静态方法不能在对象上执行操作。但是，静态方法可以访问静态字段。

import java.time.LocalDate;public class Employee {public static int nextId = 1;public static int getNextId() {//静态方法访问静态常量return nextId;}private String name;private double salary;protected LocalDate hireDate;{this.name=name;}
}

在下面两种情况下使用静态方法

方法不需要访问对象状态，因为它需要的所有参数都通过显示参数提供(例如，Math.pow)
方法只需要访问类的静态字段。

1.4 static的注意事项

静态方法只能访问静态变量和静态方法
非静态方法可以访问静态变量或者静态方法，也可以访问非静态的成员变量和非静态的成员方法
静态方法中是没有this关键字

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

非静态方法，参数里都默认有一个this，谁调用这个非静态方法，this就是谁（this是记录的地址值）。
在这里插入图片描述
但是静态方法里是没this的

因为非静态的方法，往往和某个对象相关的，所以有this。而静态方法不属于任何对象，是共享的，所以没有this。

二多态

2.1 认识多态

在这里插入图片描述
Student有两种形态，一个是学生形态，一个是人形态，这就是多态。

什么是多态?
同类型的对象，表现出的不同形态（对象的多种形态）

多态的表现形式
父类类型对象名称 = 子类对象

多态的前提

有继承/实现关系
有父类引用指向子类对象 Fu f=new Zi();
有方法重写

2.2 多态场景

案例

public class Person {private String name;private int age;public Person(String name, int age) {this.name = name;this.age = age;}public Person() {}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 void show(){System.out.println(name+","+age);}
}

public class Student extends Person{@Overridepublic void show() {System.out.println("学生的信息："+getName()+","+getAge());}
}

public class Teacher extends Person{@Overridepublic void show() {System.out.println("老师的信息："+getName()+","+getAge());}
}

public class Administrator extends Person{@Overridepublic void show() {System.out.println("管理员的信息："+getName()+","+getAge());}
}

测试：

public class Test {public static void main(String[] args) {//创建三个对象，并调用reister方法Student s = new Student();s.setName("张三");s.setAge(18);Teacher t = new Teacher();t.setName("王建国");t.setAge(30);Administrator admin = new Administrator();admin.setName("管理员");admin.setAge(35);register(s);register(t);register(admin);}//这个方法既能接收老师，又能接收学生，还能接收管理员，只能把参数写成这三个类型的父类public static void register(Person p) {//调用子类的show方法p.show();}
}

结果：
在这里插入图片描述

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

2.3 多态调用成员的特点

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

class Animal {String name = "动物";public void show() {System.out.println("Animal --- show方法");}
}class Dog extends Animal {String name = "狗";@Overridepublic void show() {System.out.println("Dog --- show方法");}
}class Cat extends Animal {String name = "猫";@Overridepublic void show() {System.out.println("Cat --- show方法");}
}

测试

public class Test {public static void main(String[] args) {//创建对象(多态方式)//Fu f = new Zi();Animal a = new Dog();//调用成员变量: 编译看左边，运行也看左边//编译看左边:javac编译代码的时候，会看左边的父类中有没有这个变量，如果有，编译成功，如果没有编译失败.// 运行也看左边: java运行代码的时候，实际获取的就是左边父类中成员变量的值System.out.println(a.name);//动物//调用成员方法: 编译看左边，运行看右边// 编译看左边:iavac编译代码的时候，会看左边的父类中有没有这个方法，如果有，编译成功，如果没有编译失败// 运行看右边: java运行代码的时候，实际上运行的是子类中的方法。a.show();///Dog --- show方法//理解://Animal a = new Dog();//现在用a去调用变量和方法的呀? 是的//而a是Animal类型的，所以默认都会从Animal这个类中去找//成员变量: 在子类的对象中，会把父类的成员变量也继承下的。父: name 子: name//成员方法: 如果子类对方法进行了重写，那么在虚方法表中是会把父类的方法进行覆盖的。}
}

2.4 多态的优势和弊端

优势

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

Person p=new student ();
p.work(); // 业务逻辑发生改变时，后续代码无需修改，即以后只需要把Student改成Teacher、worker等即可

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

弊端
多态下，对象不能调用子类特有方法（只能调用父类存在的方法）


class Animal {public void eat() {System.out.println("动物在吃东西");}
}class Dog extends Animal {@Overridepublic void eat() {System.out.println("狗吃狗头");}public void lookHoom(){System.out.println("狗看家");}
}class Cat extends Animal {String name = "猫";@Overridepublic void eat() {System.out.println("猫吃小鱼干");}public void catchMouse(){System.out.println("猫抓老鼠");}
}

测试

public class Test {public static void main(String[] args) {Animal a = new Dog();//编译看左边，运行看右边a.eat();//多态的弊端：不能调用子类的特有功能//a.lookHome()报错，  报错的原因：当调用成员方法的时候，编译看左边，运行看右边//即在编译的时候会先检查左边的父类中有没有这个方法，如果没有直接报错。//解决方案:变回子类类型就可以了//细节:转换的时候不能瞎转，如果转成其他类的类型，就会报错//Cat c = (Cat) a;//c.catchMouse();/*if (a instanceof Dog) {Dog d = (Dog) a;d.lookHome();} else if (a instanceof Cat) {Cat c = (Cat) a;c.catchMouse();} else {System.out.println("");}*///jdk14新特性(新写法，效果和上边一样)//先判断a是否为Dog类型，如果是，则强转成Dog类型，转换之后变量名为d//如果不是，则不强转，结果直接是falseif (a instanceof Dog d) {d.lookHome();} else if (a instanceof Cat c) {c.catchMouse();} else {System.out.println("");}}

三内部类

类的五大成员：
属性、方法、构造方法、代码块、内部类

3.1 什么是内部类

在一个类的里面，再定义一个类。为了实现更好的封装性。
举例:在A类的内部定义B类，B类就被称为内部类

在这里插入图片描述

需求:写一个avabean类描述汽车。
属性:汽车的品牌，车龄，颜色，发动机的品牌，使用年限

车里有发动机，而发动机又是一个独立个体
在这里插入图片描述
内部类表示的事物是外部类的一部分，内部类单独出现没有任何意义

内部类的访问特点

内部类可以直接访问外部类的成员，包括私有
外部类要访问内部类的成员，必须创建对象

在这里插入图片描述

什么时候使用内部类

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

3.2 成员内部类

类定义在了成员位置 (类中方法外称为成员位置，无static修饰的内部类)
在这里插入图片描述
成员内部类特点：

无static修饰的内部类，属于外部类对象的。
宿主：外部类对象。

内部类的使用格式：

 外部类.内部类。 // 访问内部类的类型都是用 外部类.内部类

获取成员内部类对象的两种方式：

方式一：外部直接创建成员内部类的对象

外部类.内部类 变量 = new 外部类（）.new 内部类（）;

方式二：在外部类中定义一个方法提供内部类的对象

案例演示

方式一：
public class Test {public static void main(String[] args) {//  宿主：外部类对象。// Outer out = new Outer();// 创建内部类对象。Outer.Inner oi = new Outer().new Inner();oi.method();}
}class Outer {// 成员内部类，属于外部类对象的。// 拓展：成员内部类不能定义静态成员。public class Inner{// 这里面的东西与类是完全一样的。public void method(){System.out.println("内部类中的方法被调用了");}}
}方式二：
public class Outer {String name;private class Inner{static int a = 10;}public Inner getInstance(){return new Inner();}
}public class Test {public static void main(String[] args) {Outer o = new Outer();System.out.println(o.getInstance());}
}

编写成员内部类的注意点

成员内部类可以被一些修饰符所修饰，比如： private，默认，protected，public，static等
在成员内部类里面，JDK16之前不能定义静态变量，JDK16开始才可以定义静态变量。
创建内部类对象时，对象中有一个隐含的Outer.this记录外部类对象的地址值。

详解：

内部类被private修饰时，外界无法直接获取内部类的对象，只能通过3.2节中的方式二获取内部类的对象

被其他权限修饰符修饰的内部类一般用3.2节中的方式一直接获取内部类的对象

内部类被static修饰是成员内部类中的特殊情况，叫做静态内部类下面单独学习。

内部类如果想要访问外部类的成员变量，外部类的变量必须用final修饰，JDK8以前必须手动写final，JDK8之后不需要手动写，JDK默认加上。

3.3 静态内部类

类定义在了成员位置 (类中方法外称为成员位置，有static修饰的内部类)

静态内部类特点：

静态内部类是一种特殊的成员内部类。

有static修饰，属于外部类本身的。
总结：静态内部类与其他类的用法完全一样。只是访问的时候需要加上外部类.内部类。
拓展1:静态内部类可以直接访问外部类的静态成员。
拓展2:静态内部类不可以直接访问外部类的非静态成员，如果要访问需要创建外部类的对象。
拓展3:静态内部类中没有Outer.this。

内部类的使用格式：

外部类.内部类。

静态内部类对象的创建格式：

外部类.内部类  变量 = new  外部类.内部类构造器;

调用方法的格式：

调用非静态方法的格式：先创建对象，用对象调用
调用静态方法的格式：外部类名.内部类名.方法名();

案例演示：

// 外部类：Outer01
class Outer01{private static  String sc_name = "黑马程序";// 内部类: Inner01public static class Inner01{// 这里面的东西与类是完全一样的。private String name;public Inner01(String name) {this.name = name;}public void showName(){System.out.println(this.name);// 拓展:静态内部类可以直接访问外部类的静态成员。System.out.println(sc_name);}}
}public class InnerClassDemo01 {public static void main(String[] args) {// 创建静态内部类对象。// 外部类.内部类  变量 = new  外部类.内部类构造器;Outer01.Inner01 in  = new Outer01.Inner01("张三");in.showName();}
}

3.4 局部内部类

类定义在方法内中的类

定义格式:

class 外部类名 {数据类型 变量名;修饰符 返回值类型 方法名(参数列表) {// …class 内部类 {// 成员变量// 成员方法}}
}

3.5 匿名内部类

是内部类的简化写法，没有名字的内部类，可以在方法中，也可以在类中方法外。开发中，最常用到的内部类就是匿名内部类了，需重点掌握。

格式：

new 类名或者接口名() {重写方法;
};

包含了：

继承或者实现关系
方法重写
创建对象

所以从语法上来讲，这个整体其实是匿名内部类对象

3.5.1 什么时候用到匿名内部类

实际上，如果我们希望定义一个只要使用一次的类，就可考虑使用匿名内部类。匿名内部类的本质作用是为了简化代码。

之前我们使用接口时，似乎得做如下几步操作：

定义子类
重写接口中的方法
创建子类对象
调用重写后的方法

interface Swim {public abstract void swimming();
}// 1. 定义接口的实现类
class Student implements Swim {// 2. 重写抽象方法@Overridepublic void swimming() {System.out.println("狗刨式...");}
}public class Test {public static void main(String[] args) {// 3. 创建实现类对象Student s = new Student();// 4. 调用方法s.swimming();}
}

我们的目的，最终只是为了调用方法，那么能不能简化一下，把以上四步合成一步呢？匿名内部类就是做这样的快捷方式。

3.5.2 匿名内部类前提和格式

匿名内部类必须继承一个父类或者实现一个父接口。

匿名内部类格式

new 父类名或者接口名(){// 方法重写@Override public void method() {// 执行语句}
};

3.5.3 使用方式

以接口为例，匿名内部类的使用，代码如下：

interface Swim {public abstract void swimming();
}public class Demo07 {public static void main(String[] args) {// 使用匿名内部类new Swim() {@Overridepublic void swimming() {System.out.println("自由泳...");}}.swimming();// 接口 变量 = new 实现类(); // 多态,走子类的重写方法Swim s2 = new Swim() {@Overridepublic void swimming() {System.out.println("蛙泳...");}};s2.swimming();s2.swimming();}
}

3.5.4 匿名内部类的特点

定义一个没有名字的内部类
这个类实现了父类，或者父类接口
匿名内部类会创建这个没有名字的类的对象

3.5.5 匿名内部类的使用场景

通常在方法的形式参数是接口或者抽象类时，也可以将匿名内部类作为参数传递。代码如下：

interface Swim {public abstract void swimming();
}public class Demo07 {public static void main(String[] args) {// 普通方式传入对象// 创建实现类对象Student s = new Student();goSwimming(s);// 匿名内部类使用场景:作为方法参数传递Swim s3 = new Swim() {@Overridepublic void swimming() {System.out.println("蝶泳...");}};// 传入匿名内部类goSwimming(s3);// 完美方案: 一步到位goSwimming(new Swim() {public void swimming() {System.out.println("大学生, 蛙泳...");}});goSwimming(new Swim() {public void swimming() {System.out.println("小学生, 自由泳...");}});}// 定义一个方法,模拟请一些人去游泳public static void goSwimming(Swim s) {s.swimming();}
}