Java面向对象编程

2025年情感分析(SA)综述——论文阅读报告 阅读详情

Java面向对象编程

参加拉勾教育大数据训练营课程笔记

类和对象

对象 - 现实生活中的具体的客观实体,Java语言中体现为内存中的一块区域

类 - 抽象出具有相同特征和行为的多个对象的抽象描述。是蓝图,设计图

类定义

类的声明

  • 类名遵循Pascal命名 - 所有单词首字母大写,比如BigData,代码文件名与类名相同,比如BigData.java

    public class ClassName {
        
    }
    
  • 构造方法

    • 初始化类的成员变量(特征变量)
    • 与类名相同,无返回类型
    • 可以重载
    • 提供构造方法后,编译器不再提供默认的无参数构造方法
    public class ClassName {
        public ClassName() {// 无参构造函数
        }
        public ClassName(int a) {// 有参构造函数
        }
    }
    
  • 成员变量 - Camel命名规范,常量则是全部大写,单词间用下划线连接(_),如private final int THIS_IS_A_CONSTANT = 0。

    public class ClassName {
        int thisIsAnInteger = 0;
        public ClassName() {// 无参构造函数
        }
        public ClassName(int a) {// 有参构造函数
        }
    }
    

    final成员变量初始化的三种方式:

    1. 直接赋值语句初始化
    2. 代码块初始化
    3. 构造函数初始化
    // 1.
    public class ClassName {
        int final thisIsAnInteger = 0;
    }
    // 2.
    public class ClassName {
        int final thisIsAnInteger;
        {
            thisIsAnInteger = 0;
        }
    }
    // 3.
    public class ClassName {
        int final thisIsAnInteger;
        public ClassName() {
            thisIsAnInteger = 0;
        }
    }
    
  • 成员方法 - Camel命名规范

    public class ClassName {
        int thisIsMethod() {} // 有返回值,无参数成员方法
        void noReturnNoParametersMethod() {} // 无返回值,无参数成员方法
        int returnWithParametersMethod(int a, int b) {} // 有返回值,有参数成员方法
        int intReturnVariableParametersMethod(int a, String...args) {} // 有返回值,有参数,有变长参数成员方法,变长参数必须放最后
    }
    

    传参注意事项:

    1. 修改基本数据类型的形参,不会影响实参的值(传值)
    2. 修改引用类型的形参,会影响实参(传址)
    3. 调用一个方法时,会为方法创建一个栈帧的存储区域,用来存储方法的参数、局部变量等,调用结束栈帧空间就被释放(数据被清除)

    方法重载,满足其一:

    • 参数个数不同
    • 参数类型不同
    • 参数顺序不同

    递推和递归求阶乘和斐波拉契数列(Fibonacci sequence):

    • 递推 - 通过循环实现
    • 递归 - 方法直接或间接调用自身

    Notes:

    递归出现性能瓶颈时,改用递推实现

  • this关键字

    • 消除歧义 - 成员方法会优先使用局部变量,当局部变量名和成员变量名相同时,用this关键字明确指定变量或方法是成员变量或方法
    • 调用成员变量、方法,作为返回值
    • 构造方法第一行调用其他形式构造方法:this([parameters...]);
    • 构造方法中指向正在构造的对象
    • 成员方法中指向当前对象

类的实例化(创建对象)

  • 在堆区申请一块存储区域,并把地址保存到引用变量中

    // ClassName.java
    class ClassName {}
    
    // ClassTest.java
    ClassName className = new ClassName([constructor parameters,...]);
    
  • className变量是一个引用,指向新的ClassName对一个对象(即保存指向保存对象的堆区的地址)。引用数据的默认初始值是null

  • 匿名对象 - new ClassName([constructor parameters,...]);

  • 构造块 - 类定义中由大括号括起来的代码块,每次实例化都会调用一次

    class ClassName {
        { // 构造代码块
            a = 1;
            b = new Connection();
        }
    }
    
  • 静态代码块,由static修饰的构造块,随着类加载时执行一次

    class ClassName {
        static { // 静态代码块
            a = 1;
            b = new Connection();
        }
    }
    

单个class中,构造块,静态代码块和构造方法的执行顺序:

  1. 静态代码块(执行一次),类加载时
  2. 构造块,实例化时
  3. 构造方法,实例化时

继承中构造块,静态代码块和构造方法的执行顺序:

  1. 先执行父类的静态代码块,再执行子类的静态代码块。

  2. 执行父类的构造块,执行父类的构造方法体。

  3. 执行子类的构造块,执行子类的构造方法体。

封装

控制成员变量合法性、合理性

对成员变量进行密封包装处理,隐藏成员变量的细节以及保证成员变量的合理性,这样的机制叫做封装

实现封装

  1. 私有化成员变量: private int anInt;

  2. 为每个私有变量编写getters和setters方法

  3. 构造方法中也要调用setters保证成员变量的合法性

JavaBean - 可重用组件,其它Java类可以通过反射机制发现和操作这些JavaBean的属性

  • 类是公共的
  • 有一个无参的公共构造方法
  • 有属性,且都有对应的get、set方法

Notes:

JavaBeen常用来定义数据实体(data entity)

static

  1. 定义静态变量、方法
  2. 与创建的对象无关,存放在内存方法区
  3. 静态变量、方法被所以方法共享
  4. 静态方法中不能使用非静态变量
  5. 静态方法中没有this关键字
  6. 可以用于getters、setters

应用 - 单例模式

  • 饿汉模式

    public class Singleton {
        private static Singleton instance = new Singleton();
        private Singleton() {}
        public getInstance() {
    		return instance;
    	}
    }
    
  • 懒汉模式

    public class Singleton {
        private static Singleton instance = null;
        private Singleton() {}
        public getInstance() {
          if(null == instance) {
            instance = new Singleton();
          }
          return instance;
        }
    }
    

Notes:

推荐使用饿汉模式,防止多线程资源抢占

继承

目标 - 提高代码的复用性,可维护性及扩展性,也是多态的前提条件

超类、父类、基类 → 子类、派生类、孩子类

类访问权限:

修饰符本类同包类子类其他类
publicYYYY
protectedYYYN
defaultYYNN
privateYNNN

继承特点

  • 当多个类之间有相同的特征和行为时,可以将相同的内容提取出来组成一个公共类,让多个类吸收公共类中已有特征和行为而在多个类型只需要编写自己独有特征和行为的机制,叫做继承。
  • 私有方法、构造方法不能继承;私有变量可以继承但不能直接访问
  • 满足逻辑关系:子类is a父类
  • 单继承,不能继承多个父类,一个父类可以由多个子类

继承的方法不能满足子类需求时,需要重写方法(override)

  • 方法名相同、参数列表相同、返回值类型相同,Java 5开始允许返回子类类型
  • 访问权限不能变小,可以不变或变大
  • 不能抛出更大的异常(异常机制)

使用super()调用父类构造方法

package

  • 相当于命名空间,防止命名冲突
  • 例子:top.datageek.project.module
  • 使用import导入包
  • Java 5后支持导入静态成员

final

  • final class不能被继承,可以防止滥用继承
  • final方法不能被重写(override),可以被继承
  • final成员变量必须初始化,不能更改
  • 很少单独使用final关键字来修饰成员变量,通常使用public static final关键字共同修饰成员变量来表达常量的含义,常量的命名规范要求是所有字母都要大写,不同的单词之间采用下划线连(A_CONSTANT)。

多态

父类引用指向子类实例(子类到父类/小到大的自动转换)

  • 父类独有的方法,子类可以访问
  • 父类子类共有的方法,子类可以访问
  • 子类独有的方法,父类引用不能访问。如果要访问需要做强制类型转换,将父类引用转为子类引用
  • 强制类型转换之前使用instanceof判断:
    if(rectangle instance of Rectangle) 
    
  • 用父类作为参数的类型,当传入不同的子类时,其行为就会是传入的子类行为(方法重写)
// Shape.java
package phase01.module2.code;

public class Shape {
    public void show() {
        System.out.println("Shape");
    }
}

// Rectangle.java
package phase01.module2.code;

public class Rectangle extends Shape {
    @Override
    public void show() {
        super.show(); // call parent's method
        System.out.println("Rectangle");
    }
}

// Circle.java
package phase01.module2.code;

public class Circle extends Shape{
    @Override
    public void show() {
        super.show();
        System.out.println("Circle");
    }
}


// ShapeTest.java
package phase01.module2.code;

public class ShapeTest {
    public static void ShapeShow(Shape shape) {
        shape.show();
    }

    public static void main(String[] args) {
        Shape rect = new Rectangle(); // parent reference points to a child's instance
        Shape circle = new Circle(); // parent reference points to a child's instance
        ShapeShow(rect); // rectangle behavior
        ShapeShow(circle); // circle behavior
    }
}

Notes:

为了代码可维护性和课扩展性,声明父类引用指向子类实例,缺点是不能直接访问子类独有方法

抽象类

抽象方法:public abstract void aMethod([parameterList...]);

抽象类:public abstract aClass {}

  • 不能实例化 - 抽象类可能包含有抽象方法,实例化后可能调用没有方法体的抽象方法

  • 可以有特征变量,可以有方法,可以有构造方法

  • 可以包含抽象方法,也可以没有 - 但最好有,否则失去了创建抽象类的意义

  • 意义

    1. 用于被继承,实现多态

    2. 继承类必须实现抽象方法,否则也必须声明为抽象类 - 模板设计模式。

Notes:

抽象方法不能是private的

接口

public interface MyInterface {
  public final int A = 1; // 必须是常量
  private void concreteMethod(){} // since Java 9
  public abstract void interfaceMethod();
}

接口声明不允许使用protected,public可以省略
在这里插入图片描述
实现声明:class A implements MyInterface

  • 一个class可以实现多个接口
  • 不能有构造方法
  • 只能包含非私有的没有方法体的抽象方法,1.9以后可以有有方法体的私有方法
  • 只能继承接口
  • 可以弥补不能多继承的不足
  • 从Java8开始增加新特性,接口中允许出现非抽象方法和静态方法,但非抽象方法需要使用default关键字修饰。意味着可以增加非抽象方法,而其实现类可以自由选择要不要实现这个新方法,增强了接口的可扩展性和可维护性

特殊类

内部类 - 仅为一个类服务

普通内部类
  • 访问外部类与本类同名成员时 - 外部类.this.同名变量/方法

  • 可以有成员变量、方法、构造方法

  • 可以使用final和abstract修饰

  • 可以使用private, protected修饰

  • 需要使用外部类对象来创建对象

  • 内部类编译产生的class文件

    NormalInnerClass$A.class
    NormalInnerClass$B.class
    NormalInnerClass$C.class
    NormalInnerClass$D.class
    NormalInnerClass$E.class
    NormalInnerClass$F.class
    

普通内部类测试代码:

// NormalInnerClass.java
package phase01.module2.code.innerclass;

public class NormalInnerClass {
    private int c = 0;

    public class A {
        private int a = 0;
        private int c = 1;

        public void show() {
            System.out.println(NormalInnerClass.this.c); // print NormalInnerClass's c - 0
            System.out.println(this.c); // print A's c - 1
        }
    }

    private class B {
        private int b = 0;
        private int c = 2;
    }

    protected class C {
        private int d = 0;
        private int c = 3;

        public void show() {
            System.out.println(NormalInnerClass.this.c); // print NormalInnerClass's c - 0
            System.out.println(this.c); // print A's c - 3
        }
    }

    private static class D {
        private int e = 0;

        private void show() {
        }
    }

    private final class E {
        private int f = 0;
    }

    private abstract class F {
        abstract void display();
    }

    public void show() {
        A a = new A();
        System.out.println(c);
        a.show();
    }
}

// NormalInnerClassTest.java
package phase01.module2.code.innerclass;

public class NormalInnerClassTest {
    public static void main(String[] args) {
        NormalInnerClass normalInnerClass = new NormalInnerClass();
        NormalInnerClass.A a = normalInnerClass.new A(); // public inner class A
        a.show();
        NormalInnerClass.C c = normalInnerClass.new C(); // protected inner class C
        c.show();
    }
}
静态内部类
  • 不能访问外部类的非静态成员
  • 可以直接通过类创建对象(不需要外部类的实例)
  • 访问和外部类同名成员,使用className.memberName

静态内部类测试代码:

// StaticInnerClass.java
package module2.code.innerclass;

public class StaticInnerClass {
    private int cnt = 0;
    private static int snt = 2;

    public static class StaticInner {
        private int ia = 3;
        private static int snt = 4;

        public StaticInner() {
            System.out.println("StaticInner");
        }

        public void show() {
            System.out.println(ia); // 3
//            System.out.println(cnt); // Non-static field 'cnt' cannot be referenced from a static context
            System.out.println(snt); // 4
        }

        public void show2(int snt) {
            System.out.println(snt); // parameter snt
            System.out.println(StaticInner.snt); // 4
            System.out.println(StaticInnerClass.snt); // 2
        }
    }
}

// StaticInnerClassTest.java
package module2.code.innerclass;

public class StaticInnerClassTest {
    public static void main(String[] args) {
        StaticInnerClass.StaticInner staticInner = new StaticInnerClass.StaticInner();
        staticInner.show();
        staticInner.show2(5);
    }
}

局部内部类
  • 声明在方法体内只在方法体内可用

  • 在方法体内直接创建对象

  • 不能使用权限访问控制(private, public, protected, static)

  • 可以使用方法的局部变量,但不允许修改,所以通常方法给内部类使用的的局部变量会声明为常量final变量,原因有两个:

    1. 内部类会复制一份方法的局部变量,如果方法体中修改了局部变量的值,内部类还会继续使用旧的值,造成潜在的难以发现的漏洞
    2. 防止在方法内部类意外尝试修改方法的局部变量,引起错误
      在这里插入图片描述
// MethodInnerClass.java
package module2.code.innerclass;

public class MethodInnerClass {
    private int cnt = 1;

    public void show() {
        final int shw = 0;
        class A {
            private int ia = 2;

            public A() {
            }

            public void test() {
                System.out.println(ia); // 2
                System.out.println(cnt); // 1
                System.out.println(shw); // 0
            }
        }
        A a = new A();
        a.test();
    }
}
// MethodInnerClassTest.java
package module2.code.innerclass;

public class MethodInnerClassTest {
    public static void main(String[] args) {
        MethodInnerClass methodInnerClass = new MethodInnerClass();
        methodInnerClass.show();
    }
}
匿名内部类

回调模式的概念

如果一个方法的参数是接口类型,则在调用该方法时,需要创建并传递一个实现此接口类型的对象;而该方法在运行时会调用到参数对象中所实现的方法(接口中定义的)。

// AnonymousInterface.java
package module2.code.anonymous;

public interface AnonymousInterface {
    public abstract void show();
}

// AnonymousInterfaceImp.java
package module2.code.anonymous;

public class AnonymousInterfaceImp implements AnonymousInterface {
    @Override
    public void show() {
        System.out.println("AnonymousInterface的一个实现");
    }
}

// AnonymousInterfaceTest.java
package module2.code.anonymous;

public class AnonymousInterfaceTest {
    public static void test(AnonymousInterface anonymousInterface) {
        anonymousInterface.show();
    }

    public static void main(String[] args) {
        test(new AnonymousInterfaceImp());
    }
}

使用匿名内部类或者lambda(Java 8以后)表达式

// AnonymousInterface.java
package module2.code.anonymous;

public interface AnonymousInterface {
    public abstract void show();
}

// AnonymousInterfaceTest.java
package module2.code.anonymous;

public class AnonymousInterfaceTest {
    public static void test(AnonymousInterface anonymousInterface) {
        anonymousInterface.show();
    }

    public static void main(String[] args) {
        test(() -> System.out.println("lambda")); // lambda
        test(new AnonymousInterface() {
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        });
    }
}

枚举类(特殊类)

定义:

  • 从Java 5开始支持
  • 枚举值就是当前类的类型,也就是指向本类的对象,默认使用public static final关键字共同修饰,因此采用枚举类型.的方式调用。
  • 枚举类可以自定义构造方法,但是构造方法的修饰符必须是private,默 认也是私有的。
// EnumDirections.java
package module2.code.direction;

public enum EnumDirections {
    UP(1), DOWN(2), LEFT(3), RIGHT(4);

    EnumDirections(int direction) {
    }
}

// EnumDirectionsTest.java
package module2.code.direction;

public class EnumDirectionsTest {
    public static void test(EnumDirections direction) {
        switch (direction) {
            case UP:
                System.out.println("UP");
                break;
            case DOWN:
                System.out.println("DOWN");
                break;
            case LEFT:
                System.out.println("LEFT");
                break;
            case RIGHT:
                System.out.println("RIGHT");
                break;
            default:
                System.out.println("DEFAULT");
        }
    }

    public static void main(String[] args) {
        test(EnumDirections.UP);
    }
}

所有枚举类继承自java.lang.Enum,继承的方法有:

方法定义解释
static T[] values()返回当前枚举类中的所有对象
String toString()返回当前枚举类对象的名称
int ordinal()获取枚举对象在枚举类中的索引位置
static T valueOf(String str)将参数指定的字符串名转为当前枚举类的对象
int compareTo(E o)Compares this enum with the specified object for order. Returns a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object. Enum constants are only comparable to other enum constants of the same enum type. The natural order implemented by this method is the order in which the constants are declared.

枚举类实现接口

  1. 整个每局类型重写一次接口的方法

    // DirectionInterface.java
    package module2.code.direction;
    
    public interface DirectionInterface {
        void show();
    }
    
    // EnumDirections.java
    package module2.code.direction;
    
    public enum EnumDirections implements DirectionInterface {
        UP(1), DOWN(2), LEFT(3), RIGHT(4);
    
        EnumDirections(int direction) {
        }
    
        @Override
        public void show() {
            System.out.println("show method called");
        }
    }
    
    // EnumDirectionsTest.java
    package module2.code.direction;
    
    public class EnumDirectionsTest {
        public static void test(EnumDirections direction) {
            switch (direction) {
                case UP:
                    System.out.println("UP");
                    break;
                case DOWN:
                    System.out.println("DOWN");
                    break;
                case LEFT:
                    System.out.println("LEFT");
                    break;
                case RIGHT:
                    System.out.println("RIGHT");
                    break;
                default:
                    System.out.println("DEFAULT");
            }
        }
    
        public static void main(String[] args) {
            EnumDirections[] values = EnumDirections.values();
            for (EnumDirections value : values) {
                value.show(); // call 4 times
            }
            test(EnumDirections.UP);
        }
    }
    
  2. 每个每局类对象重写一次接口方法,4个不同的show()方法重写。每局的每个值实际就是类的一个由public static final修饰的实例,由于类实现了接口,所以作为实例,必须实现接口,这里有匿名内部类实现。
    在这里插入图片描述

    // DirectionInterface.java
    package module2.code.direction;
    
    public interface DirectionInterface {
        void show();
    }
    
    // EnumDirections.java
    package module2.code.direction;
    
    public enum EnumDirections implements DirectionInterface {
    
        UP(1){
            @Override
            public void show() {
                System.out.println("UP");
            }
        }, DOWN(2) {
            @Override
            public void show() {
                System.out.println("DOWN");
            }
        }, LEFT(3) {
            @Override
            public void show() {
                System.out.println("LEFT");
            }
        }, RIGHT(4) {
            @Override
            public void show() {
                System.out.println("RIGHT");
            }
        };
    
        EnumDirections(int direction) {
        }
    }
    
    // EnumDirectionsTest.java
    package module2.code.direction;
    
    public class EnumDirectionsTest {
        public static void test(EnumDirections direction) {
            switch (direction) {
                case UP:
                    System.out.println("UP");
                    break;
                case DOWN:
                    System.out.println("DOWN");
                    break;
                case LEFT:
                    System.out.println("LEFT");
                    break;
                case RIGHT:
                    System.out.println("RIGHT");
                    break;
                default:
                    System.out.println("DEFAULT");
            }
        }
    
        public static void main(String[] args) {
            EnumDirections[] values = EnumDirections.values();
            for (EnumDirections value : values) {
                value.show(); // 4 different overrides of show method
            }
            test(EnumDirections.UP);
        }
    }
    

注解(特殊的接口)

  • 注解(Annotation)又叫标注,是从Java5开始增加的一种引用数据类型。

  • 注解本质上就是代码中的特殊标记,通过这些标记可以在编译、类加载、 以及运行时执行指定的处理。

  • 通过@注解名称的方式可以修饰包、类、 成员方法、成员变量、构造方法、参数、局部变量的声明等。

定义:

访问修饰符 @interface 注解名 {
    注解成员;
}
  • 注解体中只有成员变量没有成员方法,而注解的成员变量以“无形参的方 法”形式来声明,其方法名定义了该成员变量的名字,其返回值定义了该 成员变量的类型。

  • 如果注解只有一个参数成员,建议使用参数名为value,而类型只能是八 种基本数据类型、String类型、Class类型、enum类型及Annotation类型。

Notes:

  1. 所有注解继承自java.lang.annotation.Annotation接口

  2. 空标记定义称为标记注解或标识注解

// MyAnnotation.java
package module2.code.annotation;

public @interface MyAnnotation {
    public String value() default "default"; // 声明一个String类型的成员变量,变量名是value,public修饰符可以省略
    public String value2(); // 声明一个String类型的成员变量,变量名是value,public修饰符可以省略
    public String value3() default "value 3"; // 声明一个String类型的成员变量,变量名是value,public修饰符可以省略
}

// Person.java
package module2.code.annotation;

@MyAnnotation(value = "A person", value2 = "value 2")
public class Person {
}

元注解 - 作用于注解的注解

  • @Retention - 有效范围,声明周期,取值如下:

    1. RetentionPolicy.SOURCE注解只在源码阶段保留,在编译器进行编译时 它将被丢弃忽视
    2. RetentionPolicy.CLASS注解只被保留到编译进行的时候,它并不会被加 载到 JVM 中,默认方式
    3. RetentionPolicy.RUNTIME注解可以保留到程序运行的时候,它会被加载 进入到 JVM 中,所以在程序运行时可以获取到它们
  • @Documented - 是否在文档注释中。使用javadoc工具可以从程序源代码中抽取类、方法、成员等注释形成一 个和源代码配套的API帮助文档,而该工具抽取时默认不包括注解。@Documented用于指定被该注解将被javadoc工具提取成文档。定义为@Documented的注解必须设置Retention值为RUNTIME。

    Notes:

    使用ItelliJ生成文档,Tools →\to→ Generate JavaDoc,给自定义参数–encoding utf-8

  • @Target - 可以修饰哪些元素。@Target用于指定被修饰的注解能用于哪些元素的修饰,取值如下:

    值解释
    ElementType.ANNOTATION_TYPE可以给一个注解进行注解
    ElementType.CONSTRUCTOR可以给构造方法进行注解
    ElementType.FIELD可以给属性进行注解
    ElementType.LOCAL_VARIABLE可以给局部变量进行注解
    ElementType.METHOD可以给方法进行注解
    ElementType.PACKAGE可以给一个包进行注解
    ElementType.PARAMETER可以给一个方法内的参数进行注解
    ElementType.TYPE可以给类型进行注解,比如类、接口、枚举

    从Java 8开始对元注解@Target的参数类型ElementType枚举值增加了两个:

    • ElementType.TYPE_PARAMETER表示该注解能写在类型变量的声明语句中,如:泛型。

    • ElementType.TYPE_USE表示该注解能写在使用类型的任何语句中。

  • @Inherited - 目标类的子类是否继承注解。并不是说注解本身可以继承,而是说如果一个超类被该注解标记过的注解进行注解时,如果子类没有被任何注解应用时,则子类就继承超类的注解

  • @Repeatable - 是否可以重复。@Repeatable表示注解可重复使用的含义,从Java 8开始增加的新特性。

    // ManTypes.java
    public @interface ManTypes {
        ManType[] value();
    }
    
    // ManType.java
    @Repeatable(value=ManTypes.class)
    public @interface ManType {}
    
    // Man.java
    @ManType("超人")
    @ManType("职工")
    //@ManTypes({@Mantype(value="职工"), @ManType(value="超人")}) // java 8以前处理多个注解的方式
    public class Man {}
    

常见的预制注解

注解名说明
@version标明该类模块的版本
@see参考转向,也就是相关主题
@since从哪个版本开始增加的
@param对方法中某参数的说明,如果没有参数就不能写
@return对方法返回值的说明,如果方法的返回值类型是void就 不能写
@exception对方法可能抛出的异常进行说明
@Override限定重写父类方法, 该注解只能用于方法
@Deprecated用于表示所修饰的元素(类, 方法等)已过时
@SuppressWarnings抑制编译器警告
复合材料成型仿真案例大全|覆盖模压 / RTM / 固化 / SMC,实操步骤直接抄 本文整理了一套完整的PAM-COMPOSITE复合材料成型仿真案例合集,涵盖模压、RTM、固化变形、SMC四大核心工艺,包含6个实操案例和1个全流程衔接案例。每个案例都配有详细的操作步骤、核心要点和缺陷排查方法,适用于不同水平的工程师和研究人员。案例内容源自实际项目,可直接复用,帮助用户快速掌握复合材料成型仿真的关键技术,解决褶皱、纤维堆积、气泡残留等常见问题,实现从铺层设计到强度校核的全流程仿真闭环。特别针对热固性/热塑性材料差异、RTM衍生工艺、链式仿真等难点提供了专项解决方案。 阅读详情

相关推荐

QMT与聚宽策略代码对接实战:Redis信号传递与xtquant交易实现

本文详细介绍了如何将聚宽策略代码与本地QMT终端进行高效对接的实战方案。通过利用Redis Stream构建可靠信号通道,解决了云端信号到本地执行的延迟与丢失问题,并结合xtquant库实现自动化交易执行。文章重点阐述了信号封装、资金映射、异步下单、风控检查及独立资金管理等核心环节,为量化交易者搭建自主可控的实盘系统提供了完整路径。

lilh34434的博客 475

老李分享:Android性能优化之内存泄漏1

老李分享:Android性能优化之内存泄漏 前言 对于内存泄漏,我想大家在开发中肯定都遇到过,只不过内存泄漏对我们来说并不是可见的,因为它是在堆中活动,而要想检测程序中是否有内存泄漏的产生,通常我们可以借助LeakCanary、MAT等工具来检测应用程序是否存在内存泄漏,MAT是一款强大的内存分析工具,功能繁多而复杂,而LeakCanary则是由Square开源的一款轻量第三方内...

weixin_30591551的博客 109

CCS TMSC6748 报错Error connecting to the target: (Error -600 @ 0x0)

CCS TMSC6748 报错Error connecting to the target:(Error -600@ 0x0)

AS_the_deer1717的博客 6637

单例模式的几种实现

单例模式是开发人员在开发中比较常用的一种设计模式,实现方式也很简单,大致原理:在我们程序开发中始终保持一个类的唯一单例,因此我们必须严格控制它的实例创建,一般的设计方式会在类中定义一个私有的成员变量instance以及一个静态的共有方法getinstance(),他负责检测和实例化自己并存储在成员变量中 1、单实现方式如下 public sealed class Singleton //...

流彩飞霞的专栏 256

2080Ti双卡开启NVLink

本文介绍了如何在Ubuntu 22.04系统下给2080Ti双卡开启NVLink的方法。

flymyd的博客 2907

医学图像分割实战:基于TransUNet训练自己的眼底硬渗出物数据集(附完整代码)

本文详细介绍了基于TransUNet的眼底硬渗出物分割实战指南,涵盖数据预处理、模型调优、训练策略及性能优化等关键环节。通过代码复现和实验对比,展示了TransUNet在医学图像分割中的优势,为糖尿病视网膜病变的早期诊断提供技术支持。

weixin_42524708的博客 365

5个Android开发中比较常见的内存泄漏问题及解决办法

在Android开发中,内存泄漏是比较常见的问题,有过一些Android编程经历的童鞋应该都遇到过,但为什么会出现内存泄漏呢?内存泄漏又有什么影响呢? 在Android程序开发中,当一个对象已经不需要再使用了,本该被回收时,而另外一个正在使用的对象持有它的引用从而导致它不能被回收,这就导致本该被回收的对象不能被回收而停留在堆内存中,内存泄漏就产生了。 内存泄漏有什么影响呢?它是

赤耳A狼 796

一种四通道高精度IEPE加速度传感器控制器设计稿

一种四通道高精度IEPE加速度传感器控制器设计稿,颇具参考价值。

boyondmcu的博客 3861

Android内存泄露案例和解析

使用过长对象生命周期 静态变量 单例 使用内部类 耗时操作 Handler.delay http://www.cnblogs.com/qianxudetianxia/p/3645106.html https://drakeet.me/android-leaks http://www.tuicool.com/articles/2AnARj http://www.

我早就想,要这样载着你,翻山越岭 2463

手把手教你配置SAP EWM HU类型及号段分配(含常见错误排查)

本文详细介绍了SAP EWM系统中HU类型及号段分配的配置方法,包括环境准备、包材主数据配置、存储类型关联及号段管理。通过实战案例和常见错误排查,帮助用户高效完成HU配置,提升仓储管理效率。重点讲解了EWM后台配置和号段配置的关键步骤与技巧。

weixin_33670786的博客 444

【面试系列】数据工程师高频面试题及详细解答

本文针对数据工程师岗位,提供了详尽的面试题库和解答,分为初级、中级和高级三个层次。初级面试题主要涉及基本的数据处理和ETL工具的使用,如SQL查询、数据清洗和基本的数据建模。中级面试题重点考察数据管道设计、数据库优化和大数据平台的应用。高级面试题则深入探讨高级数据处理技术、分布式系统架构和数据湖的实现。通过这些问题和解答,候选人可以全面了解数据工程师岗位所需的技能,帮助其更好地准备面试。常考知识点总结部分则系统归纳了数据工程师岗位的关键技能领域。

在路上的专栏 2376

Java 面向对象编程详解

抽象指将事物的共性提取出来,忽略掉非本质的细节。Java 中主要通过抽象类和接口来实现抽象。Java 的面向对象编程以封装、继承、多态和抽象为核心,通过关键字(如thissuperfinalstatic)和构造方法等语法特性实现复杂功能。进一步通过内部类、接口、Lambda 表达式等扩展了 OOP 的应用场景。同时,采用组合设计、遵循 SOLID 原则及常见设计模式,可以编写出更具扩展性、灵活性和可维护性的代码。理解这些概念后,你只需多实践、不断阅读优秀代码,相信“一看就会”的效果会逐步实现。

wincl0的博客 1675

流媒体之LL-HLS 低延时HLS协议

LL-HLS协议通过扩展了HLS协议,为实时直播场景提供了更丰富的功能,如延迟控制、播放列表增量更新、阻止播放列表重新加载等。同时客户端可以更灵活地控制播放列表的加载和播放,以适应各种场景和需求。LL-HLS在直播中的延时可以控制在3s内, 但是即使这样, 还是不如RTMP, RTSP等协议的实时性。

技术控的笔记 3368

深入浅析Java面向对象编程

面向对象编程(Object-Oriented Programming,简称OOP)是一种编程范式,它将现实世界的事物抽象为程序中的对象,通过对象之间的交互来完成程序的功能。面向对象编程的核心思想是将数据和处理数据的方法封装在一起,形成一个具有独立功能的实体。

2302_79319046的博客 2224

华为的C语言编程规范.pdf

华为技术有限公司内部技术规范。本规范制定了编写C语言程序的基本原则、规则和建议。从代码的清晰、简洁、可测试、安全、程序效率、可移植各个方面对C语言编程作出了具体指导。

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

java面向对象编程的理解

面向对象编程(OOP)是一种将软件开发与现实世界模型相结合的编程范式,通过封装、继承、多态和抽象等特性,极大地提高了代码的可读性和可维护性。OOP允许开发者创建更灵活和可扩展的系统,简化复杂性,使得大型项目的开发和维护变得更加高效。Java作为一种流行的OOP语言,以其跨平台特性和强大的社区支持,成为现代软件开发的主流选择,适用于各种企业级应用和移动开发。

2301_81311226的博客 2065

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

JAVA面向对象编程

JAVA的背景和历史JAVA的特点和应用领域如何安装和配置JAVA开发环境面向对象编程是一种非常流行的编程范式,Java作为一种面向对象编程语言,也广泛使用这种编程范式。本文详细介绍了Java中的面向对象编程基本概念,包括类和对象、封装、继承和多态等。并举例说明了电子商务系统和游戏开发两个实例。希望本文能够帮助初学者更好地理解和掌握Java中的面向对象编程。类和对象的定义和使用Java是一门面向对象编程语言,类和对象是Java中最基本的概念之一。

Kali与编程 1208

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

java面向对象编程总结

在经过十周的java学习后,我对于原本一窍不通的课程又有了新的理解,它也并不是原本我不认识之前高冷的模样,我在慢慢的接触它,认识它,了解它。但现在为止,我对于我所学习的java中的“面向对象编程”做一个个人总结,其中观点仅代表个人,如有错误,敬请纠正。 在我所学习的教材中,将“面向对象编程”分为1,2,3三个章节,我也将我所学习的内容分为三个点来进行总结。 面向对象编程1 什么是面向对象 在这个章节里面,我们知道了什么是面向对象,如果用一个比喻来说的话,面向对象就像是养花一样,买个花瓶,再买束鲜花,不喜

weixin_64926930的博客 2140

Java面向对象编程介绍

代码复用是面向对象编程的一个重要目标,通过继承和多态等特性,可以实现代码的重用,减少代码的重复性。继承允许子类继承父类的属性和方法,多态允许不同对象对同一消息做出不同的响应,这些特性使得代码更易于复用和扩展,提高了代码的效率和质量。同时,继承允许子类继承父类的属性和方法,可以实现代码的重用和扩展,进一步提高了代码的可维护性。封装是面向对象编程的一个重要特性,它将数据和方法封装在对象内部,隐藏对象的内部实现细节,只暴露必要的接口给外部使用,提高了代码的可维护性和复用性。

qq_75066841的博客 1365

Java面向对象编程详解

本文深入浅出地介绍了Java面向对象编程的核心概念和实践技巧。从类与对象的基本概念入手,详细讲解了封装、继承、多态三大特性,并通过实例演示了构造方法、this关键字、static成员和内部类等重要知识点。无论您是Java初学者还是希望巩固基础的开发者,这篇文章都将帮助您构建扎实的面向对象编程思维,提升代码设计与实现能力。

m0_73850645的博客 965

Java面向对象编程的理解

通过继承,我们可以实现代码的复用,提高开发效率。例如,我们可以定义一个“动物”类,然后让“狗”类和“猫”类继承“动物”类,共享“动物”类的属性和行为。封装是OOP的核心概念之一,它通过将对象的属性和方法组合在一起,并隐藏对象的内部实现细节,只暴露必要的接口给外界。总之,Java的面向对象编程是一种强大的编程范式,它将现实世界的事物抽象成对象,通过类、对象、封装、继承和多态等概念,实现了代码的模块化、可维护性和可扩展性。在OOP中,对象是由类(Class)实例化而来的,类定义了对象的属性和行为。

2301_78499479的博客 686
上一篇: Java语言基础
下一篇: Java核心类库(上)
DataPeak
博客等级 码龄15年 32粉丝 68原创
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值