#java7 features | Explore Tumblr posts and blogs

datadot-ittraining · 6 years ago

Text

Core Java Training Institutes in Hyderabad

Core Java Online Training Institutes in Ameerpet:The versatile, portable Java programming language has helped create thousands of highly skilled jobs in the ITindustry. Java training can give applications developers and other professionals a competitive edge. Our Java training provide students with a firm foundation in the programming language:

Concepts, methods and variables of object-oriented programming

Implementation of the language as Web deployment

This course can be a significant help for students trying to break into the tech field, as well as established professionals looking to advance their careers or take on a new set of challenges in the workplace.

Application Programmer

Software Developer

CORE JAVA Introduction • Why Java? Java versus C/C++ • Java history, features, applications • JDK versions, JDK installations Tokens • Identifiers, Data types, Keywords • Variables, Constants • Literals, Comments Type casting Command-Line Arguments Java Class • Variables, Methods, Constructors • Instance blocks, Static blocks Operators Conditional Statements • If, if-else,nested if-else, switch Looping Statements • While,do-while,for,for each Arrays OOPS • Class, Object • Inheritance, Polymorphism (overloading, overriding, dynamic method dispatch) • This, super, final keywords • Abstraction, Encapsulation Garbage Collection Annotations Packages • Predefined packages • User-defined packages • Importing packages • Access Modifiers – private, public, protected, abstract – volatile, synchronized Interface • Interface declarations • Marker interface • Adaptor classes • Interface vs inheritance String Manipulation • StringBuffer, StringBuilder • StringTokenizer Wrapper Class • Data types vs Wrapper classes • All 8 wrapper classes explanations • Auto boxing vs Auto unboxing • toString(), parseXXX(),valueOf(), XXXValue() Exception Handling • Introduction, Types of Exceptions • Exception vs Error • Try-catch blocks usage • Finally block usage • Throw/ Throws keyword usage • Customized Exceptions • Types of Exceptions and error Multi Threading • Introduction to multitasking • Process based vs thread based • Defining Instantiating • Starting the Thread • Life Cycle stages of a Thread • Setting & getting name of Thread • Thread Priorities • Preventing Thread from Execution (yield(),join(),sleep()) • Thread Synchronization • Inter Thread Communication • Dead Lock, Daemon Thread Nested / Inner Classes • Introduction, Advantages • Normal Inner classes • Method local inner classes • Anonymous / Static nested classes JAVA.IO.package • Introduction • Byte oriented streams • Character Oriented Streams • Writing & reading operations on file • Normal vs Buffered streams. • File class, Serialization • Deserialization Enumeration • Introduction, Advantages • Enum vs enum • Enum vs class Generics • Type safety Collection Framework • Introduction to Arrays • Adv of collection • Collection vs Collections, Cursors • Key interfaces, Characteristics, • Interface implementation classes – List, Set, Map • Comparable vs comparator • Sorting mechanisms Applets • Introduction to Applets • Advantages & Disadvantages • Life cycle of Applets • Creating Applets • Applet with parameters AWT (Abstract Window Tool Kit) • Introduction, Frame class, Layouts • Components of AWT • Event Handling Event delegation Model • Different types of Listeners Internationalization (I18N) • Design application to support different country languages • Local class, ResourceBundle • Date in different formats • Info about properties file JVM Architecture • JVM Structure, Components JAVA7, JAVA8 FEATURES Related Searches are :Computer Training Institutes for Core java, Best Computer Training Institutes for Core java, Live Projects Core java, Best Institute for Core java in ameerpet, Computer Training Institutes For Core java, Best Core java Training institutes in Ameerpet, Best Training institute for Core java,Institute for Core java,Online training for Core java, Core java training institute in ameerpet

For More info : www.datadot.in (or) Call us at : 9052641113 / 9052651113

#best online training in ameerpet python training in ameerpet best training institutes in hyderabad pega training institute in ameerpet w

0 notes

simplexianpo · 5 years ago

Text

Java： Error&Exception - Exceptional features of Java7

##Abnormal

**If there is an error in the code, the program will stop running.**

Exceptions do not refer to syntax errors, syntax errors, compilation failures, no bytecode files, and no operation at all.

Exception handling is one of the criteria to measure whether a language is mature. The mainstream languages such as Java, C++ and C# support exception handling mechanisms, which can make programs more fault-tolerant and make program codes more robust(Unfortunately, the traditional C# has no exception handling, and only programs can express abnormal situations by using specific return values of methods, and use if statements to judge normal and abnormal situations.).

###There is no shortcoming of exception mechanism

```

1：Using the return value of the method to represent exceptions is limited, and it is impossible to exhaust all exceptions

2：Abnormal flow code and normal flow code are mixed together, which increases the complexity of the program and is poor in readability

3：With the continuous expansion of the system scale, the maintainability of the program is extremely low

```

###Aiming at the defect that there is no exception mechanism with the previous group, the solution is:

```

1:Describe different types of abnormal situations as different classes (called abnormal classes)

2:Separate abnormal flow code from correct flow code

3:Flexible handling of exceptions, if the current method can not handle it, it should be handed over to the caller for handling

```

**Note: Throwable class is a superclass of all errors or exceptions in Java language**

###Abnormal conditions (the program will terminate after occurrence)

```

Error : Indicates an error, which generally refers to an irreparable error related to JVM. Such as system crash, memory overflow, JVM error, etc., which are thrown by JVM, we don't need to deal with it.

Almost all subclasses use Error as the suffix of the class name(However, the designers of the test framework set a large number of exception classes as Error.).

Exception : It indicates abnormality, which means that an abnormal condition occurs in the program, and the problem can be repaired. Almost all subclasses use Exception as the suffix of the class name.

If an exception occurs, you can copy the simple class name of the exception to the API for checking.

```

1：Common Error

```

StackOverflowError : This error is thrown when the application recursion is too deep and memory overflow occurs.

```

2：Common Exception

```

1.NullPointerException : Null pointer exception generally means that when an object is null, the method and field of the object are called

2.ArrayIndexOutOfBoundsException : The index of the array is out of bounds (less than 0 or greater than or equal to the array length)

3.NumberFormatException : Abnormal number formatting generally refers to converting strings other than 0~9 into integers

```

If an exception occurs, the program will be terminated immediately, so the exception needs to be handled

1 This method does not handle, but declares throwing, which is handled by the caller of this method

2 Use the statement block of try-catch in the method to handle exceptions

Use try-catch to catch a single exception with the following syntax

try{

Write code that may cause exceptions

}catch(ExceptionType e){

Code for handling exceptions

//Log/print exception information/continue to throw exceptions, etc

}

Note: try and catch cannot be used alone and must be used together (try can also be used only with finally)

###Get exception information Throwable class method

```

1、String getMessage() : Get the description information and reason of the exception (when prompted to the user, prompt the error reason)

2、String toString() : Get trace stack information of exception (not used)

3、void printStackTrace() : The abnormal trace stack information is printed and output to the console without using System.out.println (); This method includes the type of exception, the cause of the exception, and the location where the exception occurs. In the development and debugging stages, printStackTrace must be used

```

**Note: At present (during development), in the catch statement block, it is necessary to write: e.printStackTrace ()**

Purpose: To view the specific information of exceptions for convenience of debugging and modification

Use try-catch to catch multiple exceptions

try{

Write code that may cause exceptions

}catch(ExceptionTypeA e){

//When a type A exception occurs in try, use this catch to capture the code that handles the exception

//Log/print exception information/continue to throw exceptions, etc

}catch(ExceptionTypeB e){

//When a type B exception occurs in try, use this catch to capture the code that handles the exception

//Log/print exception information/continue to throw exceptions, etc

}

Note:

```

1.A catch statement can only catch one type of exception. If you need to catch multiple exceptions, you must use multiple catch statements(Enhanced catch after JDK1.7)。

2.Code can only have one type of exception at a moment, only one catch is needed, and it is impossible to have multiple exceptions at the same time.

```

###finally

**Finally statement block: indicates the code that will be executed eventually, with or without exception.**

When some physical resources (disk files/network connections/database connections, etc.) are opened in the try statement block. Have to be used after the completion of the final closure of open resources.

####Two kinds of syntax of finally

```

1：try...finally : At this time, there is no catch to catch exceptions, because at this time, exceptions will be automatically thrown according to the application scenario, and there is no need to handle them by yourself.

2：try...catch...finally : You need to handle exceptions yourself, and eventually you have to shut down resources

Note: finally cannot be used alone

When only the relevant methods of exiting JVM are called out in try or catch, finally will not be executed at this time, otherwise finally will always be executed

```

>System.exit()：Exit JVM

###Classification of Exception :

```

1、Compilation-time exception: checked exception, which will be checked during compilation. If exception is not handled, compilation fails.

2、Runtime exception: runtime exception. During runtime, the exception is checked; during compilation, the compiler will not detect the runtime exception (no error is reported).

Running exception: at compile time, it can be handled or not handled

```

###Exception thrown

```

throw : Used inside the method to return an exception object to the caller, which will end the current method just like return.

Throws : Used above the method declaration to indicate that the current method does not handle exceptions, but reminds the caller of the method to handle exceptions (throw exceptions).

```

Throw Statement: used inside a method to throw a specific exception

throw new ExceptionClass ("exception information"); //termination method

####throw：

Generally, when a method is abnormal, I don't know what the method should return. At this time, I always return an error and continue to throw exceptions upward in the catch statement block.

Return is to return a value and throw is to return an error to the caller of the method.

If every method gives up handling exceptions, they are thrown directly through throws declaration, and finally exceptions will run to the main method. If the main method does not handle them at this time, the processing mechanism that continues to be thrown to the bottom layer of JVM is to print the trace stack information of exceptions.

**Runtime exception, which is handled by default.**

###Custom exception class:

There are different exception classes in Java, which represent a specific exception, so there are always some exceptions that SUN has not defined well in the development, and it is necessary to define exception classes according to the exceptions of its own business.

####How to define exception classes:

```

Method 1: customize an exception class to be checked: customize the class and inherit from java.lang.Exception

Method 2: customize a runtime exception class: customize the class and inherit from java.lang.RuntimeException

```

#####Exception translation:

When the subsystem at the top level doesn't need to care about a drama at the bottom, the common way is to capture the original exception, convert it into a new exception of different types, and then throw a new exception.

#####Abnormal chain:

Packaging the original exception into a new exception class, thus forming an orderly arrangement of multiple exceptions, which is helpful to find the root cause of generating exception classes.

Unusual new features of Java7 (Android doesn't use Java7 and supports Java5/Java6 syntax)

```

1：Enhanced throw

2：Multiple anomaly capture

3：Automatic resource shutdown

```

>It is more accurate to handle thrown Exceptions in Java7, and no longer use exception declaration to throw them in general

### Principles for handling exceptions:

```

1：Exceptions can only be used in abnormal situations, and the existence of try-catch will also affect performance

2：It is necessary to provide explanatory documents for exceptions, such as java.doc If an exception is customized or a method throws an exception, it should be recorded in the document comments

3：Avoid anomalies as much as possible

4：The granularity of exceptions is very important. A try-catch block should be defined for a basic operation. Don't put hundreds of lines of code into a try-cathc block for simplicity

5：Exception handling in a loop is not recommended, and exceptions should be captured outside the loop (try-catch is used outside the loop)

6：Use RuntimeException type as much as possible for custom exceptions

```

###Running order of statement blocks that catch exceptions:

public class ExceptionTest {

public static void main(String[] args) {

System.out.println(testMethod());

}

static int testMethod() {

int t = 1;

try {

System.out.println("Enter the try statement block----t:" + t);

t++;

System.out.println(t / 0);

System.out.println("Leave the try statement block----t:" + t);

return t;

} catch (ArithmeticException e) {

System.out.println("Enter ArithmeticException----t:" + t);

t++;

System.out.println("Exit ArithmeticException----t:" + t);

return t;

} catch (Exception e) {

System.out.println("Enter Exception----t:" + t);

t++;

System.out.println("Exit Exception----t:" + t);

return t;

} finally {

System.out.println("Enter the finally statement block----t:" + t);

t = 10;

System.out.println("Leave the finally statement block----t:" + t);

return t;

}

Output results are:

Enter the try statement block----t:1

Enter ArithmeticException----t:2

Exit ArithmeticException----t:3

Enter the finally statement block----t:3

Leave the finally statement block----t:10

#Java #Basic #Exception

0 notes