Learn BCA Tuition with Free Lessons & Tips

public class doWhilePracticleEx {

public void test() {

}

public static void main(String args[]) {

String q1 = "Who is PM of India?";
String a1 = "Sonia Gandhi";
String a2 = "Rahul Gandhi";
String a3 = "Amit Shah";
String a4 = "Narendra Modi";


System.out.println(q1);
System.out.println(a1);
System.out.println(a2);
System.out.println(a3);
System.out.println(a4);
String user="";

int attemptCount=1; //no of attempts

do {
if(attemptCount==1) {
System.out.println("Enter Your answer");
}
Scanner sc = new Scanner(System.in);
//control + shift+ o
user = sc.nextLine();
attemptCount++;


} while(!user.equalsIgnoreCase(a4));
System.out.println("Your answer is correct!!!!!");
}

}

public class ListIteratorEx {

public static void main(String args[]) {

List<String> li = new ArrayList<String>();
li.add("java1");
li.add("java2");
li.add("java3");
li.add("java4");


ListIterator itr = li.listIterator();
while(itr.hasNext()) {
System.out.println(itr.next());
}

System.out.println(itr.nextIndex());

System.out.println(itr.previousIndex());

}

}

In this video, learn about Java and its advantages. Also, check out the difference between Java and C++, Java development kit, Java Run Time Environment (JRE) with a proper demonstration program for better clarity.

What are Design Patterns?

Design Pattern is a used and tested solution for a known problem. In simple words, you can say a general reusable solution to a commonly occurring problem within a given context in software design. 

Why Design Patterns?

Because good software design requires considering issues that may not become visible until later in the implementation.

It prevents issues that can cause a significant problem in the software and also improves the code readability.

Different types of Design pattern by GOF(Gang of Four):

1. Creational Design Pattern
2. Structural Design Pattern
3. Behavioural Design Pattern

Again they have also categorised into different types, such as:

Creational Design Pattern, DP = Design Pattern

• Factory Method DP
• Abstract Factory DP
• Builder DP
• Prototype DP
• Singleton DP

Structural Design Pattern:

• Adapter DP
• Bridge DP
• Composite DP
• Decorator DP
• Facade DP
• Flyweight DP
• Proxy DP

Behavioural Design Pattern:

• Observer DP
• State DP
• Strategy DP
• Iterator DP
• Chain of Responsibility DP
• Command DP
• Interpreter DP
• Mediator DP
• Memento DP
• Template Method DP
• Visitor DP

Is it necessary to use design pattern always? No, because we should not try to force the code into a specific way; instead, notice which practices crystallise out of your code. I mean, writing a program that does X using the pattern Y is not a good idea.

The question is, when did you start doing everything using patterns? Not all solution fit neatly into an existing design pattern, and adopting a practice may mean that you muddy the cleanness of your solution.

What is the difference between Design-Pattern and Framework?

1. DP are the recurring solution to a problem that can come in an application or software life. A framework is a group of components that helps each other provide a reusable architecture for the application.
2. DP are logical. The framework is more physical.
3. DP is independent of language, whereas the framework depends on the language.
4. DP is generic and can be used in any application, whereas the framework is domain-specific.

To be continued.

Following figures relate to Rajkot Mills Ltd. For the year 2019: Fixed factory overhead 400,000, fixed Selling and Distribution Overhead 200,000, variable cost per unit 12, selling price per unit 20. Calculate:

• Break-even point in units.
• Units to be sold to earn a target net income of Rs. 5000 per month during a year.
• The number of units to earn a net income of 25% on cost.
• Selling price per unit if the break-even point is to be brought down by 15,000 units.

1. Break-even point is when the total cost = total revenue. Let x be the number of units manufactured.
200,000 + 400,000 + 12x (which is the total variable cost of x units) = 20x (which is the total revenue)
This gives us x = 600,000/8 = 75,000 units.
2. Net income of 5,000 per month means the income of 60,000 in the year. Since net income is revenue minus cost, this means 20x - 12x - 600,000 = 60,000, where x is number of units sold.
This gives us x = 660,000/8 = 82,500 units.
3. A net income of 25% on cost means a net income of 0.25( 600,000 + 12x) = 150,000 + 3x
Similar to the previous question, we now get the equation
20x - 12x - 600,000 = 150,000 + 3x, which gives us
5x = 750,000 or x = 150,000 units
4. Let the selling price per unit be y. If 15,000 units bring down the breakeven point (i.e. x), it will be 60,000 units. Substituting that in the equation for breakeven point will give us
600,000 + 12(60,000) = 60,000y
Therefore, y = 22.

While designing and development, one should think in terms of compile-time and run-time.It helps in understanding language basics in a better way.Let's understand this with a question below :

What is the difference between line 1 & line 2 in the following code snippet?

public class CompileAndRuntimeTest{
     static final int number1 = 5;
     static final int number2 = 6;
     static int number3 = 5;
     static int number4= 6;

public static void main(String[ ] args) {
    int product1 = number1 * number2; //line 1
    int product2 = number3 * number4; //line 2
}
}

Line 1, evaluates the product at compile-time, and Line 2 evaluates the product at runtime. If you use a Java Decompiler (e.g. jd-gui), and decompile the compiled CompileAndRuntimeTest.class file, you will see why , as shown below:

public class CompileAndRuntimeTest
{
   static final int number1 = 5;
   static final int number2 = 6;
   static int number3 = 5;
   static int number4 = 6;

public static void main(String[ ] args)
{
   int product1 = 30;//line 1 ---Here is the diff. Decompiled code 
   int product2 = number3 * number4; //line 2
}
}

Constant folding is an optimization technique used by the Java compiler. Since final variables cannot change, they can be optimized. Java Decompiler and javap command are handy tool for inspecting the compiled (i.e. byte code ) code.

Question for readers  :)  :

Can you think of scenarios other than code optimization, where inspecting a compiled code is useful?

Java actually does not have full form. But historically speaking, a company who owned java previously was named as OAK, because OAK was trademarked by OAK Technologies. Obviously, they wanted to change their name because of the confusion of the people. They selected around 15 titles and came up with finalizing three names that are JAVA, DNA and SILK. Eventually, JAVA was selected.

But having said that, JAVA is jokingly abbreviated by programmers as “JUST ANOTHER VIRTUAL ACCELERATOR.”

Happy Coding