https://DevOpsCloud.io -- Cloud Monk Losang Jinpa, Ph.D., MCSE/MCT, GitOps DevOps Engineer

IBM Enterprise COBOL for z/OS - Communicating with Java methods

Return to IBM Enterprise COBOL for z/OS - Communicating with Java methods

ISO COBOL-2023, COBOL, Effective Java, COBOL for z/OS (https://www.ibm.com/docs/en/cobol-zos/6.4?topic=programs-writing-object-oriented), https://www.microfocus.com/documentation/visual-cobol/VC40/Intro_to_OO_Programming_for_COBOL_Developers.pdf

Visual COBOL - Object-Oriented Programming for COBOL - Object-Oriented COBOL - https://www.microfocus.com/documentation/visual-cobol/vc50/VS2019/GUID-A80CA9E8-7B68-4637-91E9-42078C8C9275.html - Managed COBOL is the collective term for JVM COBOLand dot NET COBOL | .NET COBOL. Managed COBOL is regular procedural COBOL with extensions to take advantage of the features of the managed frameworks. This includes COBOL object-oriented (COBOL OOP - OOP COBOL) syntax that allows access to large libraries of functionality you can use in your COBOL application, and much more. To take full advantage of Managed COBOL, it is helpful to understand the object oriented COBOL concepts. See also: https://cobol.ninja/object-oriented-cobol

Return to Effective Polyglot Programming by Cloud Monk, ISO COBOL-2023, CPP Core Guidelines (CG) by Bjarne Stroustrup and Herb Sutter | C++ Core Guidelines (CG) by Bjarne Stroustrup and Herb Sutter, CPP | C++, Effective Java, Effective Spring Boot, Effective Scala, Effective Kotlin, Effective CPP | Effective C++, Effective Swift, Effective TypeScript, Effective JavaScript, Effective PHP, Effective Golang, Effective Rust, Effective C Language, Effective Clojure, Effective Haskell, Effective Elixir, Effective Erlang, Effective Elm, Effective PowerShell, Effective F Sharp, Effective Dart, Effective R Language, Effective Ruby, Effective Julia, Effective Fortran

Have The Borg rewrite Effective Java for COBOL-2023 as Effective COBOL-2023

See:

Writing object-oriented COBOL programs - https://www.ibm.com/docs/en/cobol-zos/6.4?topic=programs-writing-object-oriented
- When you write an object-oriented (OO) program, you have to determine what classes you need and the methods and data that the classes need to do their work.

Communicating with Java methods - https://www.ibm.com/docs/en/cobol-zos/6.4?topic=programs-communicating-java-methods
- To achieve COBOL interoperability with Java, you need to follow certain rules and guidelines for using services in the Java Native Interface (JNI), coding data types, and compiling COBOL programs.

https://www.zmainframes.com/viewtopic.php?t=10030

Effective IBM Object-Oriented Enterprise COBOL for z/OS - Table of Contents

Inspired by and Based on Effective Java, Third Edition by Joshua Bloch, Pearson Education Inc., 2018, ISBN-13: 978-0-13-468599-1, ISBN-10: 0-13-468599-7

Contents

Foreword

Preface

Acknowledgments

1 Introduction

2 Creating and Destroying Objects

3 Methods Common to All Objects

4 Classes and Interfaces

5 Generics

6 Enums and Annotations

7 Lambdas and Streams

8 Methods

9 General Programming

10 Exceptions

11 Concurrency

12 Serialization

Items Corresponding to Second Edition

References

Index

Appendix: Items Corresponding to Second Edition

Second Edition Item Number

Third Edition Item Number, Title

1

1, Consider static factory methods instead of constructors

2

2, Consider a builder when faced with many constructor parameters

3

3, Enforce the singleton property with a private constructor or an enum type

4

4, Enforce noninstantiability with a private constructor

5

6, Avoid creating unnecessary objects

6

7, Eliminate obsolete object references

7

8, Avoid finalizers and cleaners

8

10, Obey the general contract when overriding equals

9

11, Always override hashCode when you override equals

10

12, Always override toString

11

13, Override clone judiciously

12

14, Consider implementing Comparable

13

15, Minimize the accessibility of classes and members

14

16, In public classes, use accessor methods, not public fields

15

17, Minimize mutability

16

18, Favor composition over inheritance

17

19, Design and document for inheritance or else prohibit it

18

20, Prefer interfaces to abstract classes

19

22, Use interfaces only to define types

20

23, Prefer class hierarchies to tagged classes

21

42, Prefer lambdas to anonymous classes

22

24, Favor static member classes over nonstatic

23

26, Don’t use raw types

24

27, Eliminate unchecked warnings

25

28, Prefer lists to arrays

26

29, Favor generic types

27

30, Favor generic methods

28

31, Use bounded wildcards to increase API flexibility

29

33, Consider typesafe heterogeneous containers

30

34, Use enums instead of int constants

31

35, Use instance fields instead of ordinals

32

36, Use EnumSet instead of bit fields

33

37, Use EnumMap instead of ordinal indexing

34

38, Emulate extensible enums with interfaces

35

39, Prefer annotations to naming patterns

36

40, Consistently use the Override annotation

37

41, Use marker interfaces to define types

38

49, Check parameters for validity

39

50, Make defensive copies when needed

40

51, Design method signatures carefully

41

52, Use overloading judiciously

42

53, Use varargs judiciously

43

54, Return empty collections or arrays, not nulls

44

56, Write doc comments for all exposed API elements

45

57, Minimize the scope of local variables

46

58, Prefer for-each loops to traditional for loops

47

59, Know and use the libraries

48

60, Avoid float and double if exact answers are required

49

61, Prefer primitive types to boxed primitives

50

62, Avoid strings where other types are more appropriate

51

63, Beware the performance of string concatenation

52

64, Refer to objects by their interfaces

53

65, Prefer interfaces to reflection

54

66, Use native methods judiciously

55

67, Optimize judiciously

56

68, Adhere to generally accepted naming conventions

57

69, Use exceptions only for exceptional conditions

58

70, Use checked exceptions for recoverable conditions and runtime exceptions for programming errors

59

71, Avoid unnecessary use of checked exceptions

60

72, Favor the use of standard exceptions

61

73, Throw exceptions appropriate to the abstraction

62

74, Document all exceptions thrown by each method

63

75, Include failure-capture information in detail messages

64

76, Strive for failure atomicity

65

77, Don’t ignore exceptions

66

78, Synchronize access to shared mutable data

67

79, Avoid excessive synchronization

68

80, Prefer executors, tasks, and streams to threads

69

81, Prefer concurrency utilities to wait and notify

70

82, Document thread safety

71

83, Use lazy initialization judiciously

72

84, Don’t depend on the thread scheduler

73

(Retired)

74