JAVA小记3（第三周）

最新推荐文章于 2024-09-25 10:59:43 发布

⁢挽歌º

最新推荐文章于 2024-09-25 10:59:43 发布

阅读量97

点赞数

文章标签： java servlet jvm

本文链接：https://blog.csdn.net/qq_66788987/article/details/130907372

版权

一、静态和静态代码块

Ⅰ、静态

1.和类相关的属性称之为静态属性

2.和类相关的方法称之为静态方法

3.静态语法就是在属性和方法前增加static关键字

如以下代码：

public class PersonTwo {
    static String mName;//在类的属性前面加static
    static void sayHello(String name){//在类的方法前面加static
        System.out.println("Hello "+name);
    }
}

静态属性和方法不属于任何一个对象，可通过类名直接调用，如上面代码，如果要调用sayHello方法，在main方法中输入PersonTwo.sayHello("张三")；即可调用PersonTwo类中的sayHello方法。

注意：静态方法中用到的属性和方法也必须是静态的。

原因：先有类再有对象、

非静态成员只有对象能调用，而静态成员可用类名直接调用，通过类名调用静态方法时，对象不一定是存在的，如果静态方法中使用了非静态成员，而非静态成员只有对象才能调用，这时就会报错。

通过这个我们可以知道，为什么要在main方法前加static关键字进行修饰

静态成员在类加载时就被加载到方法区里，main方法由java解释器调用，这时还没有任何对象产生，因此，main方法成了程序的“入口”

Ⅱ、静态代码块

语法：static{

}

类信息加载完成后，会自动加载静态代码块

二、面向对象——继承性

二、继承

类存在父子关系:子类可以直接获取到父类的成员属性和成员方法。

注：类的继承只能是单继承，不支持多继承。一个类只能有一个父类，不能存在多个父类，一个父类可以有多个子类。

语法：class 类名 extends 父类名{ }

在子类中，如果子类的属性和方法名和父类的一致，可用super和this关键字区分，super表示上一级的对象，即父类，this表示当前类的对象。

三、内部类

//所谓的外部类，就是在源码中直接声明的类

//所谓的内部类，就是在类中声明的类

//Java不允许外部类使用private,protected修饰

//因为内部类可以看作外部类的属性，所以需要构建外部类对象才可以使用

下面是一段声明内部类的代码：

public class JavaStudyThree {
    public static void main(String[] agrs){
    OutClass outclass=new OutClass();
    OutClass.InClass inclass=outclass.new InClass();
    }
}
class OutClass{
    public class InClass{
        
    }
}

四、单例模式

①如果一个类的构造过程十分的复杂，而且需要经过多个步骤，如果可以直接从外部构建对象的话，可能会缺失一些必要的东西，导致对象随时出现问题。

②对象的构建比较消耗资源，可能会占用较大的内存空间，不想在外部频繁的创建。

这时，需要创建一个特殊的类，无论在外面构建多少次对象，都是指同一个对象。

public class JavaStudyThree {
    public static void main(String[] agrs){
    User user1=User.getInstance();
    User user2=User.getInstance();
    User user3=User.getInstance();
    //user1、user2、user3都是指同一个对象
    }
}
class User{
    private static User user=null;
    private User(){

    }
    public static User getInstance(){
        if(user==null){
            user=new User();
        }
        return user;
    }
}

像这种有套路的代码编写方式称为代码的设计模式，以上代码有个单独的模式名称，称为单例模式，但是这段代码在多线程场景下会出现问题，在这里暂时不讨论。

五、final关键字

在JAVA中提供了一种语法，数据一旦初始化之后就不能修改，使用关键字final

一般将于final修饰的变量称之为常量，或者叫不可变变量

①final可以修饰变量:

变量的值一旦初始化后无法修改

②final可以修饰属性:

final如果用来修饰属性，那么JVM无法自动进行初始化，需要自己进行初始化，属性值不能发生变化一般将于inal修饰的变量称之为常量，或者叫不可变变量

③final可以修饰方法：这个方法不能被子类重写

④final可以修饰类：这样类就没有子类

⑤final可以修饰方法的参数：一旦修饰，参数就无法修改

注：final不能修饰构造方法

六、抽象类和抽象方法

我们把没有方法体的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类。

抽象方法：没有方法体的方法
抽象类：包含抽象方法的类

注意：Ⅰ.含有抽象方法的类一定是抽象类，抽象类中不一定含抽象方法。

Ⅱ.final和abstract不能同时使用

抽象类：abstract class 类名{}

抽象方法：abstract 返回值类型方法名（参数）{}

子类可以继承抽象类，如果抽象类中含有抽象方法，子类需要重写抽象方法，将方法补充完整。

七、接口

Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。

接口：interface 接口名{}

//接口是抽象的，接口的方法也是抽象的，接口的属性必须要是具体的、静态的，访问权限必须是公共的。

//接口可以继承其他接口，支持多继承

//类的对象需要遵循接口，在Java中，这个遵循称之为实现，类需要实现接口，而且可以实现接口。

实现接口：class 类名 implements 接口名{}

下面是接口的一个案例：

public class JavaStudyThree {
    public static void main(String[] agrs){
        Computer computer=new Computer();
        Light light1=new Light();
        computer.usb1=light1;
        Light light2=new Light();
        computer.usb2=light2;
        computer.powerSupply();
    }
}
interface USBInstance{

}
interface USBSupply extends USBInstance{
    public void powerSupply();
}
interface USBReceive extends USBInstance{
    public void powerReceive();
}
class Computer implements USBSupply{
    public USBReceive usb1;
    public USBReceive usb2;
    public void powerSupply(){
        System.out.println("电脑提供电源");
        usb1.powerReceive();
        usb2.powerReceive();
    }
}
class Light implements USBReceive{
    public void powerReceive(){
        System.out.println("电灯接收能源");
    }
}

接口比较抽象，更详细的可以参考JAVA基础——接口（全网最详细教程）_刘扬俊的博客-CSDN博客

本周的学习到此结束了。