{"id":3448,"date":"2019-06-20T11:43:42","date_gmt":"2019-06-20T11:43:42","guid":{"rendered":"http:\/\/softlect.in\/?p=3448"},"modified":"2019-06-20T12:02:07","modified_gmt":"2019-06-20T12:02:07","slug":"java-exception-handling","status":"publish","type":"post","link":"http:\/\/softlect.com\/index.php\/java-exception-handling\/","title":{"rendered":"Java Exception Handling"},"content":{"rendered":"

<\/a>Exception Handling<\/strong><\/h1>\n

 <\/p>\n

An exception <\/em>is an abnormal condition that arises in a code sequence at run time. In other words, an exception is a run-time error. In computer languages that do not support exception handling, errors must be checked and handled manually typically through the use of error codes, and so on. This approach is as cumbersome as it is troublesome. Java\u2019s exception handling avoids these.<\/p>\n

 <\/p>\n

<\/a>Exception-Handling Fundamentals<\/strong><\/h2>\n

A Java exception is an object that describes an exceptional (that is, error) condition that has occurred in a piece of code. When an exceptional condition arises, an object representing that exception is created and thrown <\/em>in the method that caused the error. That method may choose to handle the exception itself, or pass it on. Either way, at some point, the exception is caught <\/em>and processed. Exceptions can be generated by the Java run-time system, or they can be manually generated by your code. Exceptions thrown by Java relate to fundamental errors that violate the rules of the Java language or the constraints of the Java execution environment. Java exception handling is managed via five keywords: try<\/strong>, catch<\/strong>, throw<\/strong>, throws<\/strong>, and finally<\/strong>. Briefly, here is how they work. Program statements that you want to monitor for exceptions are contained within a try <\/strong>block. If an exception occurs within the try <\/strong>block, it is thrown. Your code can catch this exception (using catch<\/strong>) and handle it in some manner. System-generated exceptions are automatically thrown by the Java run-time system. To manually throw an exception, use the keyword throw<\/strong>. Any exception that is thrown out of a method must be specified as such by a throws <\/strong>clause. Any code that absolutely must be executed before a method returns is put in a finally <\/strong>block. This is the general form of an exception-handling block:<\/p>\n

try {<\/p>\n

\/\/ block of code to monitor for errors<\/p>\n

}<\/p>\n

catch (ExceptionType1 exOb<\/em>) {<\/p>\n

\/\/ exception handler for ExceptionType1<\/em><\/p>\n

}<\/p>\n

catch (ExceptionType2 exOb<\/em>) {<\/p>\n

\/\/ exception handler for ExceptionType2<\/em><\/p>\n

}<\/p>\n

\/\/ …<\/p>\n

finally {<\/p>\n

\/\/ block of code to be executed before try block ends<\/p>\n

}<\/p>\n

Here, ExceptionType <\/em>is the type of exception that has occurred. The remainder of this chapter describes how to apply this framework.<\/p>\n

 <\/p>\n

<\/a>Exception Types<\/strong><\/h2>\n

All exception types are subclasses of the built-in class Throwable<\/strong>. Thus, Throwable <\/strong>is at the top of the exception class hierarchy. Immediately below Throwable <\/strong>are two subclasses that partition exceptions into two distinct branches. One branch is headed by Exception<\/strong>. This class is used for exceptional conditions that user programs should catch. This is also the class that you will subclass to create your own custom exception types. There is an important subclass of Exception<\/strong>, called RuntimeException<\/strong>. Exceptions of this type are automatically defined for the programs that you write and include things such as division by zero and invalid array indexing<\/p>\n

<\/a>Uncaught Exceptions<\/h3>\n

Before you learn how to handle exceptions in your program, it is useful to see what happens when you don\u2019t handle them. This small program includes an expression that intentionally causes a divide-by-zero error.<\/p>\n

class Exc0 {<\/p>\n

public static void main(String args[]) {<\/p>\n

int d = 0;<\/p>\n

int a = 42 \/ d;<\/p>\n

}<\/p>\n

}<\/p>\n

When the Java run-time system detects the attempt to divide by zero, it constructs a new exception object and then throws <\/em>this exception. This causes the execution of Exc0 <\/strong>to stop, because once an exception has been thrown, it must be caught <\/em>by an exception handler and dealt with immediately. In this example, we haven\u2019t supplied any exception handlers of our own, so the exception is caught by the default handler provided by the Java run-time system. Any exception that is not caught by your program will ultimately be processed by the default handler. The default handler displays a string describing the exception, prints a stack trace from the point at which the exception occurred, and terminates the program. Here is the output generated when this example is executed.<\/p>\n

 <\/p>\n

java.lang.ArithmeticException: \/ by zero<\/p>\n

at Exc0.main(Exc0.java:4)<\/p>\n

 <\/p>\n

Notice how the class name, Exc0<\/strong>; the method name, main<\/strong>; the filename, Exc0.java<\/strong>; and the line number, 4<\/strong>, are all included in the simple stack trace. Also, notice that the type of the exception thrown is a subclass of Exception <\/strong>called ArithmeticException<\/strong>, which more specifically describes what type of error happened. As discussed later in this chapter, Java supplies several built-in exception types that match the various sorts of run-time errors that can be generated. For example, here is another version of the preceding program that introduces the same error but in a method separate from main( )<\/strong>:<\/p>\n

class Exc1 {<\/p>\n

static void subroutine() {<\/p>\n

int d = 0;<\/p>\n

int a = 10 \/ d;<\/p>\n

}<\/p>\n

public static void main(String args[]) {<\/p>\n

Exc1.subroutine();<\/p>\n

}<\/p>\n

}<\/p>\n

 <\/p>\n

The resulting stack trace from the default exception handler shows how the entire call stack is displayed:<\/p>\n

 <\/p>\n

java.lang.ArithmeticException: \/ by zero<\/p>\n

at Exc1.subroutine(Exc1.java:4)<\/p>\n

at Exc1.main(Exc1.java:7)<\/p>\n

 <\/p>\n

As you can see, the bottom of the stack is main<\/strong>\u2019s line 7, which is the call to subroutine( )<\/strong>, which caused the exception at line 4. The call stack is quite useful for debugging, because it pinpoints the precise sequence of steps that led to the error.<\/p>\n

<\/a>Using try and catch<\/h3>\n

Although the default exception handler provided by the Java run-time system is useful for debugging, you will usually want to handle an exception yourself. Doing so provides two benefits. First, it allows you to fix the error. Second, it prevents the program from automatically terminating. Most users would be confused (to say the least) if your program stopped running and printed a stack trace whenever an error occurred! Fortunately, it is quite easy to prevent this. To guard against and handle a run-time error, simply enclose the code that you want to monitor inside a try <\/strong>block. Immediately following the try <\/strong>block, include a catch <\/strong>clause that specifies the exception type that you wish to catch. To illustrate how easily this can be done, the following program includes a try <\/strong>block and a catch <\/strong>clause which processes the ArithmeticException <\/strong>generated by the division-by-zero error:<\/p>\n

 <\/p>\n

class Exc2 {<\/p>\n

public static void main(String args[]) {<\/p>\n

int d, a;<\/p>\n

try { \/\/ monitor a block of code.<\/p>\n

d = 0;<\/p>\n

a = 42 \/ d;<\/p>\n

System.out.println(“This will not be printed.”);<\/p>\n

} catch (ArithmeticException e) { \/\/ catch divide-by-zero error<\/p>\n

System.out.println(“Division by zero.”);<\/p>\n

}<\/p>\n

System.out.println(“After catch statement.”);<\/p>\n

}<\/p>\n

}<\/p>\n

 <\/p>\n

This program generates the following output:<\/p>\n

Division by zero.<\/p>\n

After catch statement.<\/p>\n

 <\/p>\n

Notice that the call to println( ) <\/strong>inside the try <\/strong>block is never executed. Once an exception is thrown, program control transfers out of the try <\/strong>block into the catch <\/strong>block. Put differently, catch <\/strong>is not \u201ccalled,\u201d so execution never \u201creturns\u201d to the try <\/strong>block from a catch<\/strong>. Thus, the line \u201cThis will not be printed.\u201d is not displayed. Once the catch <\/strong>statement has executed, program control continues with the next line in the program following the entire try<\/strong>\/catch <\/strong>mechanism. A try <\/strong>and its catch <\/strong>statement form a unit. The scope of the catch <\/strong>clause is restricted to those statements specified by the immediately preceding try <\/strong>statement. A catch <\/strong>statement cannot catch an exception thrown by another try <\/strong>statement (except in the case of nested try <\/strong>statements, described shortly). The statements that are protected by try <\/strong>must be surrounded by curly braces. That is, they must be within a block. You cannot use try <\/strong>on a single statement. The goal of most well-constructed catch <\/strong>clauses should be to resolve the exceptional condition and then continue on as if the error had never happened. For example, in the next program each iteration of the for <\/strong>loop obtains two random integers. Those two integers are divided by each other, and the result is used to divide the value 12345. The final result is put into a<\/strong>. If either division operation causes a divide-by-zero error, it is caught, the value of a <\/strong>is set to zero, and the program continues.<\/p>\n

 <\/p>\n

\/\/ Handle an exception and move on.<\/p>\n

import java.util.Random;<\/p>\n

class HandleError {<\/p>\n

public static void main(String args[]) {<\/p>\n

int a=0, b=0, c=0;<\/p>\n

Random r = new Random();<\/p>\n

for(int i=0; i<32000; i++) {<\/p>\n

try {<\/p>\n

b = r.nextInt();<\/p>\n

c = r.nextInt();<\/p>\n

a = 12345 \/ (b\/c);<\/p>\n

} catch (ArithmeticException e) {<\/p>\n

System.out.println(“Division by zero.”);<\/p>\n

a = 0; \/\/ set a to zero and continue<\/p>\n

}<\/p>\n

System.out.println(“a: ” + a);<\/p>\n

}<\/p>\n

}<\/p>\n

}<\/p>\n

<\/a>Displaying a Description of an Exception<\/h3>\n

Throwable <\/strong>overrides the toString( ) <\/strong>method defined by Object<\/strong> so that it returns a string containing a description of the exception. You can display this description in a println( ) <\/strong>statement by simply passing the exception as an argument. For example, the catch <\/strong>block in the preceding program can be rewritten like this:<\/p>\n

 <\/p>\n

catch (ArithmeticException e) {<\/p>\n

System.out.println(“Exception: ” + e);<\/p>\n

a = 0; \/\/ set a to zero and continue<\/p>\n

}<\/p>\n

 <\/p>\n

When this version is substituted in the program, and the program is run, each divide-by-zero error displays the following message:<\/p>\n

 <\/p>\n

Exception: java.lang.ArithmeticException: \/ by zero<\/p>\n

 <\/p>\n

While it is of no particular value in this context, the ability to display a description of an exception is valuable in other circumstances\u2014particularly when you are experimenting with exceptions or when you are debugging.<\/p>\n

 <\/p>\n

<\/a>Multiple catch Clauses<\/strong><\/h2>\n

In some cases, more than one exception could be raised by a single piece of code. To handle this type of situation, you can specify two or more catch <\/strong>clauses, each catching a different type of exception. When an exception is thrown, each catch <\/strong>statement is inspected in order, and the first one whose type matches that of the exception is executed. After one catch <\/strong>statement executes, the others are bypassed, and execution continues after the try<\/strong>\/catch <\/strong>block. The following example traps two different exception types:<\/p>\n

 <\/p>\n

\/\/ Demonstrate multiple catch statements.<\/p>\n

class MultiCatch {<\/p>\n

public static void main(String args[]) {<\/p>\n

try {<\/p>\n

int a = args.length;<\/p>\n

System.out.println(“a = ” + a);<\/p>\n

int b = 42 \/ a;<\/p>\n

int c[] = { 1 };<\/p>\n

c[42] = 99;<\/p>\n

} catch(ArithmeticException e) {<\/p>\n

System.out.println(“Divide by 0: ” + e);<\/p>\n

} catch(ArrayIndexOutOfBoundsException e) {<\/p>\n

System.out.println(“Array index oob: ” + e);<\/p>\n

}<\/p>\n

System.out.println(“After try\/catch blocks.”);<\/p>\n

}<\/p>\n

}<\/p>\n

 <\/p>\n

This program will cause a division-by-zero exception if it is started with no commandline parameters, since a <\/strong>will equal zero. It will survive the division if you provide a command-line argument, setting a <\/strong>to something larger than zero. But it will cause an ArrayIndexOutOfBoundsException<\/strong>, since the int <\/strong>array c <\/strong>has a length of 1, yet the program attempts to assign a value to c[42]<\/strong>. Here is the output generated by running it both ways:<\/p>\n

 <\/p>\n

C:\\>java MultiCatch<\/p>\n

a = 0<\/p>\n

Divide by 0: java.lang.ArithmeticException: \/ by zero<\/p>\n

After try\/catch blocks.<\/p>\n

C:\\>java MultiCatch TestArg<\/p>\n

a = 1<\/p>\n

Array index oob: java.lang.ArrayIndexOutOfBoundsException<\/p>\n

After try\/catch blocks.<\/p>\n

 <\/p>\n

When you use multiple catch <\/strong>statements, it is important to remember that exception subclasses must come before any of their superclasses. This is because a catch <\/strong>statement that uses a superclass will catch exceptions of that type plus any of its subclasses. Thus, a subclass would never be reached if it came after its superclass. Further, in Java, unreachable code is an error. For example, consider the following program:<\/p>\n

 <\/p>\n

\/* This program contains an error.<\/p>\n

A subclass must come before its superclass in<\/p>\n

a series of catch statements. If not,<\/p>\n

unreachable code will be created and a<\/p>\n

compile-time error will result.<\/p>\n

*\/<\/p>\n

class SuperSubCatch {<\/p>\n

public static void main(String args[]) {<\/p>\n

try {<\/p>\n

int a = 0;<\/p>\n

int b = 42 \/ a;<\/p>\n

} catch(Exception e) {<\/p>\n

System.out.println(“Generic Exception catch.”);<\/p>\n

}<\/p>\n

\/* This catch is never reached because<\/p>\n

ArithmeticException is a subclass of Exception. *\/<\/p>\n

catch(ArithmeticException e) { \/\/ ERROR – unreachable<\/p>\n

System.out.println(“This is never reached.”);<\/p>\n

}<\/p>\n

}<\/p>\n

}<\/p>\n

 <\/p>\n

If you try to compile this program, you will receive an error message stating that the second catch <\/strong>statement is unreachable because the exception has already been caught. Since ArithmeticException <\/strong>is a subclass of Exception<\/strong>, the first catch <\/strong>statement will handle all Exception<\/strong>-based errors, including ArithmeticException<\/strong>. This means that the second catch <\/strong>statement will never execute. To fix the problem, reverse the order of the catch <\/strong>statements.<\/p>\n

 <\/p>\n

<\/a>Nested try Statements<\/strong><\/h2>\n

The try <\/strong>statement can be nested. That is, a try <\/strong>statement can be inside the block of another try<\/strong>. Each time a try <\/strong>statement is entered, the context of that exception is pushed on the stack. If an inner try <\/strong>statement does not have a catch <\/strong>handler for a particular exception, the stack is unwound and the next try <\/strong>statement\u2019s catch <\/strong>handlers are inspected for a match. This continues until one of the catch <\/strong>statements succeeds, or until all of the nested try <\/strong>statements are exhausted. If no catch <\/strong>statement matches, then the Java run-time system will handle the exception. Here is an example that uses nested try <\/strong>statements:<\/p>\n

 <\/p>\n

\/\/ An example of nested try statements.<\/p>\n

class NestTry {<\/p>\n

public static void main(String args[]) {<\/p>\n

try {<\/p>\n

int a = args.length;<\/p>\n

\/* If no command-line args are present,<\/p>\n

the following statement will generate<\/p>\n

a divide-by-zero exception. *\/<\/p>\n

int b = 42 \/ a;<\/p>\n

System.out.println(“a = ” + a);<\/p>\n

try { \/\/ nested try block<\/p>\n

\/* If one command-line arg is used,<\/p>\n

then a divide-by-zero exception<\/p>\n

will be generated by the following code. *\/<\/p>\n

if(a==1) a = a\/(a-a); \/\/ division by zero<\/p>\n

\/* If two command-line args are used,<\/p>\n

then generate an out-of-bounds exception. *\/<\/p>\n

if(a==2) {<\/p>\n

int c[] = { 1 };<\/p>\n

c[42] = 99; \/\/ generate an out-of-bounds exception<\/p>\n

}<\/p>\n

} catch(ArrayIndexOutOfBoundsException e) {<\/p>\n

System.out.println(“Array index out-of-bounds: ” + e);<\/p>\n

}<\/p>\n

} catch(ArithmeticException e) {<\/p>\n

System.out.println(“Divide by 0: ” + e);<\/p>\n

}<\/p>\n

}<\/p>\n

}<\/p>\n

 <\/p>\n

As you can see, this program nests one try <\/strong>block within another. The program works as follows. When you execute the program with no command-line arguments, a divide-by-zero exception is generated by the outer try <\/strong>block. Execution of the program by one command-line argument generates a divide-by-zero exception from within the nested try <\/strong>block. Since the inner block does not catch this exception, it is passed on to the outer try <\/strong>block, where it is handled. If you execute the program with two command-line arguments, an array boundary exception is generated from within the inner try <\/strong>block. Here are sample runs that illustrate each case:<\/p>\n

 <\/p>\n

C:\\>java NestTry<\/p>\n

Divide by 0: java.lang.ArithmeticException: \/ by zero<\/p>\n

C:\\>java NestTry One<\/p>\n

a = 1<\/p>\n

Divide by 0: java.lang.ArithmeticException: \/ by zero<\/p>\n

C:\\>java NestTry One Two<\/p>\n

a = 2<\/p>\n

Array index out-of-bounds:<\/p>\n

java.lang.ArrayIndexOutOfBoundsException<\/p>\n

 <\/p>\n

Nesting of try <\/strong>statements can occur in less obvious ways when method calls are involved. For example, you can enclose a call to a method within a try <\/strong>block. Inside that method is another try <\/strong>statement. In this case, the try <\/strong>within the method is still nested inside the outer try <\/strong>block, which calls the method. Here is the previous program recoded so that the nested try <\/strong>block is moved inside the method nesttry( )<\/strong>:<\/p>\n

 <\/p>\n

\/* Try statements can be implicitly nested via<\/p>\n

calls to methods. *\/<\/p>\n

class MethNestTry {<\/p>\n

static void nesttry(int a) {<\/p>\n

try { \/\/ nested try block<\/p>\n

\/* If one command-line arg is used,<\/p>\n

then a divide-by-zero exception<\/p>\n

will be generated by the following code. *\/<\/p>\n

if(a==1) a = a\/(a-a); \/\/ division by zero<\/p>\n

\/* If two command-line args are used,<\/p>\n

then generate an out-of-bounds exception. *\/<\/p>\n

if(a==2) {<\/p>\n

int c[] = { 1 };<\/p>\n

c[42] = 99; \/\/ generate an out-of-bounds exception<\/p>\n

}<\/p>\n

} catch(ArrayIndexOutOfBoundsException e) {<\/p>\n

System.out.println(“Array index out-of-bounds: ” + e);<\/p>\n

}<\/p>\n

}<\/p>\n

public static void main(String args[]) {<\/p>\n

try {<\/p>\n

int a = args.length;<\/p>\n

\/* If no command-line args are present,<\/p>\n

the following statement will generate<\/p>\n

a divide-by-zero exception. *\/<\/p>\n

int b = 42 \/ a;<\/p>\n

System.out.println(“a = ” + a);<\/p>\n

nesttry(a);<\/p>\n

} catch(ArithmeticException e) {<\/p>\n

System.out.println(“Divide by 0: ” + e);<\/p>\n

}<\/p>\n

}<\/p>\n

}<\/p>\n

The output of this program is identical to that of the preceding example.<\/p>\n

 <\/p>\n

<\/a>finally<\/strong><\/h2>\n

When exceptions are thrown, execution in a method takes a rather abrupt, nonlinear path that alters the normal flow through the method. Depending upon how the method is coded, it is even possible for an exception to cause the method to return prematurely. This could be a problem in some methods. For example, if a method opens a file upon entry and closes it upon exit, then you will not want the code that closes the file to be bypassed by the exception-handling mechanism. The finally <\/strong>keyword is designed to address this contingency. finally <\/strong>creates a block of code that will be executed after a try<\/strong>\/catch <\/strong>block has completed and before the code following the try\/catch <\/strong>block. The finally <\/strong>block will execute whether or not an exception is thrown. If an exception is thrown, the finally <\/strong>block will execute even if no catch <\/strong>statement matches the exception. Any time a method is about to return to the caller from inside a try\/catch <\/strong>block, via an uncaught exception or an explicit return statement, the finally <\/strong>clause is also executed just before the method returns. This can be useful for closing file handles and freeing up any other resources that might have been allocated at the beginning of a method with the intent of disposing of them before returning. The finally <\/strong>clause is optional. However, each try <\/strong>statement requires at least one catch <\/strong>or a finally <\/strong>clause. Here is an example program that shows three methods that exit in various ways, none without executing their finally <\/strong>clauses:<\/p>\n

 <\/p>\n

\/\/ Demonstrate finally.<\/p>\n

class FinallyDemo {<\/p>\n

\/\/ Through an exception out of the method.<\/p>\n

static void procA() {<\/p>\n

try {<\/p>\n

System.out.println(“inside procA”);<\/p>\n

throw new RuntimeException(“demo”);<\/p>\n

} finally {<\/p>\n

System.out.println(“procA’s finally”);<\/p>\n

}<\/p>\n

}<\/p>\n

\/\/ Return from within a try block.<\/p>\n

static void procB() {<\/p>\n

try {<\/p>\n

System.out.println(“inside procB”);<\/p>\n

return;<\/p>\n

} finally {<\/p>\n

System.out.println(“procB’s finally”);<\/p>\n

}<\/p>\n

}<\/p>\n

\/\/ Execute a try block normally.<\/p>\n

static void procC() {<\/p>\n

try {<\/p>\n

System.out.println(“inside procC”);<\/p>\n

} finally {<\/p>\n

System.out.println(“procC’s finally”);<\/p>\n

}<\/p>\n

}<\/p>\n

public static void main(String args[]) {<\/p>\n

try {<\/p>\n

procA();<\/p>\n

} catch (Exception e) {<\/p>\n

System.out.println(“Exception caught”);<\/p>\n

}<\/p>\n

procB();<\/p>\n

procC();<\/p>\n

}<\/p>\n

}<\/p>\n

 <\/p>\n

In this example, procA( ) <\/strong>prematurely breaks out of the try <\/strong>by throwing an exception. The finally <\/strong>clause is executed on the way out. procB( )<\/strong>\u2019s try <\/strong>statement is exited via a return <\/strong>statement. The finally <\/strong>clause is executed before procB( ) <\/strong>returns. In procC( )<\/strong>, the try <\/strong>statement executes normally, without error. However, the finally <\/strong>block is still executed. Here is the output generated by the preceding program:<\/p>\n

inside procA<\/p>\n

procA\u2019s finally<\/p>\n

Exception caught<\/p>\n

inside procB<\/p>\n

procB\u2019s finally<\/p>\n

inside procC<\/p>\n

procC\u2019s finally<\/p>\n

 <\/p>\n

<\/a>Java\u2019s Built-in Exceptions<\/strong><\/h2>\n

Inside the standard package java.lang<\/strong>, Java defines several exception classes. A few have been used by the preceding examples. The most general of these exceptions are subclasses of the standard type RuntimeException<\/strong>. Since java.lang <\/strong>is implicitly imported into all Java programs, most exceptions derived from RuntimeException <\/strong>are automatically available. Furthermore, they need not be included in any method\u2019s throws <\/strong>list. In the language of Java, these are called unchecked exceptions <\/em>because the compiler does not check to see if a method handles or throws these exceptions. The unchecked exceptions defined in java.lang <\/strong>are listed in Table 10-1. Table 10-2 lists those exceptions defined by java.lang <\/strong>that must be included in a method\u2019s throws <\/strong>list if that method can generate one of these exceptions and does not handle it itself. These are called checked exceptions. <\/em>Java defines several other types of exceptions that relate to its various class libraries.<\/p>\n

 <\/p>\n

 <\/p>\n","protected":false},"excerpt":{"rendered":"

Exception Handling   An exception is an abnormal condition that arises in a code sequence at run time. In other words, an exception is a run-time error. In computer languages… <\/p>\n","protected":false},"author":1,"featured_media":3470,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":[],"categories":[83],"tags":[],"aioseo_notices":[],"amp_enabled":true,"_links":{"self":[{"href":"http:\/\/softlect.com\/index.php\/wp-json\/wp\/v2\/posts\/3448"}],"collection":[{"href":"http:\/\/softlect.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/softlect.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/softlect.com\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"http:\/\/softlect.com\/index.php\/wp-json\/wp\/v2\/comments?post=3448"}],"version-history":[{"count":2,"href":"http:\/\/softlect.com\/index.php\/wp-json\/wp\/v2\/posts\/3448\/revisions"}],"predecessor-version":[{"id":3487,"href":"http:\/\/softlect.com\/index.php\/wp-json\/wp\/v2\/posts\/3448\/revisions\/3487"}],"wp:featuredmedia":[{"embeddable":true,"href":"http:\/\/softlect.com\/index.php\/wp-json\/wp\/v2\/media\/3470"}],"wp:attachment":[{"href":"http:\/\/softlect.com\/index.php\/wp-json\/wp\/v2\/media?parent=3448"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/softlect.com\/index.php\/wp-json\/wp\/v2\/categories?post=3448"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/softlect.com\/index.php\/wp-json\/wp\/v2\/tags?post=3448"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}