#mobile programming

AngularJS lets extend HTML with new attributes called Directives. AngularJS has a set of built-in directives which offers functionality to your applications. AngularJS also lets to define our own directives. Mainly the AngularJS framework can be divided into three major parts: Ng-app: This directive defines and links an AngularJS application to HTML. Ng-model: This directive binds the values of AngularJS application data to HTML input controls. Ng-bind: This directive binds the AngularJS application data to HTML tags. Ng-init: This directive initializes application data ng-app directive: The ng-app directive tells AngularJS that this is the root element of the AngularJS application. All AngularJS applications must have a root element. We can only have one ng–app directive in our HTML document.It initializes the AngularJS framework automatically. AngularJS framework will first check for the ng-app directive in an HTML document after the entire document is loaded and if ng-app is found, it bootstraps itself and compiles the HTML template. SYNTAX

In Java every program comprises classes and interfaces consisting of variables and methods. Every Java class can be having the following elements: Class − A class can be defined as a template that describes the behavior/state that the object of its type support. A programmer must keep in mind certain rules while declaring Java classes. Rules: There can be one public class per source code file. The name of the source file must match the public class name defined in the source file. If a class is to be defined in a package, then the package statement must be the first line in the source code file. Class names should be nouns, in mixed case with the first letter of each internal word capitalized. Try to keep your class names simple and descriptive. Declarinlg Classes: A class declaration contains the class keyword and the name of the class the programmer wants to define. The following code snippet declares a Dog class public class Dog{ String color; int age; String color; void barking() { } void hungry() { } void sleeping() { } } A class can contain any of the following variable types. Local variables − Variables defined inside methods, constructors or blocks are called local variables. The variable will be declared and initialized within the method and the variable will be destroyed when the method has completed. Instance variables − Instance variables are variables within a class but outside any method. These variables are initialized when the class is instantiated. Instance variables can be accessed from inside any method, constructor or blocks of that particular class. Class variables − Class variables are variables declared within a class, outside any method, with the static keyword. A class can have any number of methods to access the value of various kinds of methods. In the above example, barking(), hungry() and sleeping() are methods. Apart from this we also need to discuss the details related to declaration to a class. Every class,method, and instance variable declared has an access control. The two categories of modifiers are Access modifiers:The access modifiers, public, protected, and private are used in method and variable declarations. Non-access modifiers: The non-access modifiers, strictfp,final, and abstract are used in addition to the access control specified for a class. For example, a class can be declared both public and final. Instantiating Classes(Creating Objects): Instantiating a class implies creating an object of a class. The new operator instantiates a class by: allocating memory for a new object, and returning a reference to that memory. Following is an example of creating an object − EXAMPLE public class Puppy { public Puppy(String name) { // This constructor has one parameter, name. System.out.println("Passed Name is :" + name ); } public static void main(String []args) { // Following statement would create an object myPuppy Puppy myPuppy = new Puppy( "tommy" ); } } This section covers how to instantiating the following classes: Non-nested Nested Instantiating the Non-Nested Classes A class can be instantiated using the new keyword. The initialization parameters can be passed during initialization. Let’s consider Account class defined for calculating the balance in a bank account on the basis of a transaction, such as deposit or withdrawal. The Account class package com.vbbs; public class Account{ protected double accountbalance; public Account(double amount) { accountbalance = amount; } public account() { accountbalance=0.0; } public void deposit(double amount) { accountbalance += amount; } public double withdraw(double amount) { if(accountbalance >= amount) { accountbalance -= amount; return amount; } else return 0.0; } public double getBalance() { return balance; } } Here the Account Non-nested class consisting of deposit, withdraw, and getBalance as class members. If a programmer need to access the Account class from within a new class,then the programmer needs to create an instance of the Account class, as shown the following: // Instantiating a class Account account = new Account(); //Instantiating a class with initialization parameter Account account = new Account(25000); //Invoking method of Account using an object account.deposit(1000); In the above code, the Account class is instantiated with and without the Initialization parameter. The instance account of the Account class is used to invoke the deposit() method. Instantiating the Nested Calsses Instantiating the nested class implies creating an object of a nested class, but before creating an instance of an inner class, a programmer must create an instance of the out class.While instantiating the inner classes, must have a direct relationship to an instance of the outer class. The following ways of instantiating the inner classes Instantiating the Inner class in the Outer class Instantiating the Inner class outside the Outer class Instantiating the Static Nested class Instantiating the Inner class in the Outer class The instance of an inner class is created in the outer class.The outer class the inner class instance to access the members of the inner class. Here we creates an instance of the NewInner class within the NewOuter class: package com.vbbs; class NewOuter{ private int k =10; public void useInner() { //instantiating an inner class NewInner inner = new NewInner(); //accessing inner class method in.useOuter(); } //declaring inner class class NewInner { public void useOuter() { System.out.println("The member of outer class is s" +s); } } //closing inner class } // closing outer class In the above code the NewOuter class accesses the NewInner class, similar to its variables. The useInner() method of the NewOuter class uses the inner instance to access the useOuter() method declared in the NewInner class. Instantiating the Inner class outside the Outer class The instance of an inner class cannot be created in a static method of the outer class, as from within a static method an instance of the outer class cannot be referred to. As a result, the reference to an instance of the outer class is required to instantiate an inner class in a static method. Here the following code instantiates the outer class and its reference is used to craete an instanceof an inner class. public static void main(String []args) { // Creating an instance of outer class NewOuter outer = new NewOuter( ); // Instantiating an inner class using the reference of outer class NewOuter.NewInner inner = outer.new NewInner(); //Accessing method of an inner class inner.useOuter(); } In the above code outer is an instance of the NewOuter class and is used as a reference to create an instance of the NewInner class. Instantiating Static Nested Classes Instantiating static nested classes from a non-enclosing class is different from instantiating static nested classes from the inner classes, see the below code: class NewOuter{ { static class NewInner { void useOuter(){ System.out.println("Accessing Inner class method"); } } public static void main(String []args) { NewOuter.Newinner outer = new NewOuter.NewInner(); outer.useouter(); } } In the above code outer instance is created to access the useOuter() method of the NewInner class.