java 面向对象高级

1.final关键字

java 复制代码
class Demo{
    public static void main(String[] args) {
        final int[] a=new int[]{1,2,3};
       // a=new int[]{4,5,6};  报错
        a[0]=5;//可以,解释了final修饰引用性变量,变量存储的地址不能被改变,但地址所指向的对象的内容可以改变
    }
}

什么是常量?

2.单例设计模式-懒汉式单例-饿汉式单例



3.枚举类



java 复制代码
//常规写法
class Constant{
    public static final int UP=0;
    public static final int DOWN=1;
    public static final int LEFT=2;
    public static final int RIGHT=3;
}
class Demo{
    public static void move(int direction){
        switch (direction){
            case Constant.UP:
                System.out.println("向上移动");
                break;
            case Constant.DOWN:
                System.out.println("向下移动");
                break;
            case Constant.LEFT:
                System.out.println("向左移动");
                break;
            case Constant.RIGHT:
                System.out.println("向右移动");
                break;
            default:
                System.out.println("无效方向");
        }
    }
}
//枚举类写法,相较于常规的好处是
/*类型安全:枚举提供了更好的类型安全,因为它们限制了变量只能取预定义的值,而常规的静态常量类则没有这种限制。
可读性:枚举通常更易于阅读和理解,因为它们使用名称而不是数字或字符串来表示常量值。
维护性:使用枚举可以更容易地管理和维护一组相关的常量值,因为它们是集中定义的。
功能扩展:枚举可以有自己的方法和属性,这为扩展功能提供了可能,而常规的静态常量类则没有这样的能力。*/
enum Direction{
    UP,DOWN,LEFT,RIGHT
}
class Demo2{
    public static void move(Direction direction){
        switch (direction){
            case UP:
                System.out.println("向上移动");
                break;
            case DOWN:
                System.out.println("向下移动");
                break;
            case LEFT:
                System.out.println("向左移动");
                break;
            case RIGHT:
                System.out.println("向右移动");
                break;
        }
    }
}

4.认识抽象类



5.模板方法设计模式


java 复制代码
class A extends fu{
    public void writemain(){
        System.out.println("特殊方法A");
    }
}
class B extends fu{
    public void writemain(){
        System.out.println("特殊方法B");
    }
}
abstract class fu{
    public final void write(){
        System.out.println("公用方法1");
        writemain();
        System.out.println("公用方法2");
    }
    public abstract void writemain();
}
class Demo{
    public static void main(String[] args) {
        fu a=new A();
        a.write();
    }
}
/*
输出:
公用方法1
特殊方法A
公用方法2
 */

6.认识接口

java 复制代码
//jdk 8之前,接口中只能定义常量和抽象方法
//接口不能创建对象
public interface A {
    String STUDENT_NAME="li hua"; //接口中默认加上 public static final
    // 等价于 public static final String STUDENT_NAME="li hua";
    void run();//接口中给方法默认加上public abstract
    //等价于 public abstract void run();
}


//Demo被称为实现类,可以同时实现多个接口,
//实现类实现多个接口必须重写全部抽象方法,否则必须定义成抽象类
public class Demo implements A{
    @Override
    public void run() {
    }
}
java 复制代码
public class Demo{
    public static void main(String[] args) {
        people p=new student();
        doctor d=new student();
        driver dr=new student();
    }
}
interface driver{}
interface doctor{}
class student extends people implements driver,doctor{}
class people{}

接口的应用案例

java 复制代码
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

public class Demo{
    public static void main(String[] args) {
        student[] s=new student[3];
        s[0]=new student("li hua","boy",90);
        s[1]=new student("zhang san","boy",100);
        s[2]=new student("tu xin yue","girl",95);
        tool t=new imp2(s);
        t.listallinfo();
        t.sumscore();
    }
}

class student{
    private String name;
    private String sex;
    private double score;

    public student(String name, String sex, double score) {
        this.name = name;
        this.sex = sex;
        this.score = score;
    }
    public student(){}
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }
}
interface tool{
    public void listallinfo();
    public void sumscore();
}
class imp1 implements tool{
    private student[] s;
    public imp1(student[] s){
        this.s=s;
    }
    @Override
    public void listallinfo() {
        for(int i=0;i<s.length;i++){
            System.out.println(s[i].getName()+" "+s[i].getSex()+" "+s[i].getScore());
        }
    }

    @Override
    public void sumscore() {
        double sum=0;
        for(int i=0;i<s.length;i++){
            sum+=s[i].getScore();
        }
        System.out.println(sum/s.length);
    }
}
class imp2 implements tool{
    private student[] s;
    public imp2(student[] s){
        this.s=s;
    }
    @Override
    public void listallinfo() {
        int flag=0;
        for(int i=0;i<s.length;i++){
            System.out.println(s[i].getName()+" "+s[i].getSex()+" "+s[i].getScore());
            if(s[i].getSex()=="boy"){
                flag++;
            }
        }
        System.out.println("男生人数:"+flag+"女生人数:"+(s.length-flag));
    }

    @Override
    public void sumscore() {
        double max=s[0].getScore();
        double min=s[0].getScore();
        double sum=0;
        for(int i=0;i<s.length;i++){
            sum+=s[i].getScore();
            if(max<s[i].getScore()){
                max=s[i].getScore();
            }
            if(min>s[i].getScore()){
                min=s[i].getScore();
            }
        }
        System.out.println("去掉一个最高分和最低分后的平均分为"+(sum-max-min)/(s.length-2));
    }
}

7.JDK8开始,接口新增的三种方法

java 复制代码
public class Demo{
    public static void main(String[] args) {
        A a=new impA();
        a.run();
        A.show();
    }
}
class impA implements A{}
interface A{
    //1.大部分情况下,接口只能写抽象方法,jdk8之后,可以写普通实例方法了,但必须加default修饰
    //默认用public修饰
    //但是接口不能构建对象,应该怎么调用该方法?利用接口的实现类的对象来调用
    default void run(){
        System.out.println("--run--");
        go();
    }
    //2.jdk9开始支持私有方法,他是私有的,利用接口的实现类的对象也不能调用了,只能使用接口中的其他实例方法来调用
    private void go(){
        System.out.println("--go--");
    }
    //3.静态方法,默认用public方法,如何调用?只能通过接口名字直接调用
    static void show(){
        System.out.println("--show--");
    }
}

8.接口的注意事项

java 复制代码
//
public class Demo{
    public static void main(String[] args) {
        
    }
}
class D implements C{
    @Override
    public void show3() {}
    @Override
    public void show1() {}
    @Override
    public void show2() {}
}
interface A{
    void show1();
}
interface B{
    void show2();
}
interface C extends A,B{
    void show3();
}

9.抽象类和接口的区别

相同点:
1.都是抽象形式,都可以抽象方法,都不能创建对象
2.都是派生子类形式,抽象类是被子类继承使用,接口是被实现类实现
3.一个类继承抽象类,或者实现接口,都必须重写玩他们的抽象方法,否则自己要成为抽象类不然会报错
4.都能支持多态,都能实现解耦合
不同点:
1.抽象类可以定义类的全部普通成员,接口只能定义常量和抽象方法(以及JDK8以后的三种新方法)
2.抽象类只能被类单继承,接口可以被类多实现
3.一个类继承抽象类就不能再继承其它类,一个类实现了接口还可以继承其他类或实现其他接口
4.抽象类体现模板思想,更利于做父类,实现代码的复用性
5.接口更适合做功能的解耦合,解耦合性更强更灵活。
6.设计目的
抽象类
主要用于代码复用和提供一个通用的模板。它体现了一种 "is - a" 的关系,即子类是一种特殊的抽象类。例如,Dog是一种Animal,Dog类可以继承Animal抽象类,复用Animal类中的属性和方法,同时实现自己特有的行为(如makeSound()方法实现狗叫)。
接口
用于定义行为规范,实现接口的类必须遵循这个规范。它体现了一种 "can - do" 的关系,即类可以做接口定义的事情。例如,如果一个类实现了Flyable接口,就表示这个类可以飞行,不管这个类是Bird还是Airplane,只要实现了Flyable接口,就必须实现fly()方法来定义飞行的行为。

10.一个案例

相关推荐
圆弧YH14 分钟前
Python →爬虫实践
开发语言·python
zy01010131 分钟前
使用 IDEA 创建 Java 项目(二)
java·人工智能·intellij-idea
luckilyil33 分钟前
Spring MVC 与 JSP 数据传输
java·spring·mvc
向阳121833 分钟前
JVM入门教程:从概念到实践
java·jvm
QTX1873034 分钟前
前端基础的讲解-JS(10)
开发语言·前端·javascript
飞升不如收破烂~35 分钟前
Spring Initializr 和 Maven 是创建 Spring 项目时可以使用的两种不同的工具
java·spring·maven
forth touch38 分钟前
c++ shared_ptr 常见构造函数
开发语言·c++
2401_8574396939 分钟前
Spring Boot编程训练系统:深入设计与实现
java·spring boot·后端
网络安全-海哥41 分钟前
【VLANPWN】一款针对VLAN的安全研究和渗透测试工具
开发语言·javascript·安全·ecmascript·php·网安入门
码蜂窝编程官方43 分钟前
【含开题报告+文档+PPT+源码】基于Spring Boot智能综合交通出行管理平台的设计与实现
java·vue.js·spring boot·后端·spring