Java for android development
Download
1 / 14

Java for android Development - PowerPoint PPT Presentation


  • 65 Views
  • Uploaded on

Java for android Development. Nasrullah Khan. Using instanceof in Android Development.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about ' Java for android Development' - heath


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

Using instanceof in android development
Using instanceof in Android Development

  • the classes such as Button, TextView, and CheckBox, which represent different types of user interface controls, are all derived from the same parent class: View. Therefore, if you wanted to create a method that took a View parameter, but had different behavior depending upon the specific type of control, you could use the instanceof mechanism to check the incoming parameter and determine exactly what kind of view control had been passed in.


void checkforTextView(View v)

{

if(v instanceofTextView)

{

// This is a TextView control

} else

{

// This is not a TextView control

}

}


Inner classes
Inner classes

  • Nested classes are called inner classes

  • You can also create nested classes in order to clearly encapsulate and define subordinate objects that only matter in the context of the outer class,

  • Inner classes can have all the features of a regular class, but their scope is limited. Inner classes have another benefit: they have full access to the class in which they are nested—this feature makes inner classes perfect for implementing adapter functionality like iterators.

  • inner classes really only exist to help the developer organize code


Using static nested classes
Using static Nested Classes

  • A static inner class defines behavior that is not tied to a specific object instance, but applies across all instances

  • User.ServerInfosInfo = new User.ServerInfo();

  • a static nested class, does not have access to members of the outer class–


Power of annoymous inner class
Power of annoymous inner class

  • Anonymous inner classes are basically developer shorthand, allowing the developer to create, define, and use a custom object all in one “line.”

  • To create an anonymous inner class, you only provide the right-hand side of the definition. Begin with the new keyword, followed by the class or interface you wish to extend or implement, followed by the class definition. This will create the class and return it as a value which you can then use to call a method


Using an anonymous inner class to define a listener
Using an Anonymous Inner Class to Define a Listener

  • Android developers often use anonymous inner classes to define specialized listeners, which register callbacks for specific behavior when an event occurs. For example, to listen for clicks on a View control, the developer must call the setOnClickListener() method, which takes a single parameter: a View.OnClickListener object.


  • Android developers often use anonymous inner classes to define specialized listeners, which register callbacks for specific behavior when an event occurs. For example, to listen for clicks on a View control, the developer must call the setOnClickListener() method, which takes a single parameter: a View.OnClickListener object.Developers routinely use the anonymous inner class technique to create, define and use their custom View.OnClickListener,


Using a named inner class
Using a named inner class define specialized listeners, which register callbacks for specific behavior when an event occurs. For example, to listen for clicks on a View control, the developer must call the

  • Let’s say you have a screen that has 100 buttons on it (we did say hypothetical, right?). Now, let’s say each button, when pressed, does the exact same thing. In this case, we’ll just listen for clicks and Toast the text from the View object passed in (the text shown on the Button that was clicked):


How to show a dialog in android
How to show a Dialog in Android define specialized listeners, which register callbacks for specific behavior when an event occurs. For example, to listen for clicks on a View control, the developer must call the


  • Create the Dialog (for example, using an define specialized listeners, which register callbacks for specific behavior when an event occurs. For example, to listen for clicks on a View control, the developer must call the AlertDialog.Builder), and then call the newly created Dialog's show() method.

  • Call the Activity's showDialog() method, passing in an int that uniquely defines what sort of Dialog you want to build. Then override onCreateDialog() to actually build the Dialog, and Android will display it for you.


Reasons to use activity showdialog
Reasons to use define specialized listeners, which register callbacks for specific behavior when an event occurs. For example, to listen for clicks on a View control, the developer must call the Activity.showDialog

  • The API docs for Activity.showDialog say that the Dialog is "managed" by the Activity which I suppose provides some benefit? But this is also true if you use the AlertDialog.Builder, I would think, because you pass in this as an argument to the Builder's constructor.

  • If your Activity is going to show the same (or a very similar) Dialog several times, this option creates it only once, instead of creating a new one each time, thus putting less strain on the system as far as allocating space for new objects, garbage collection, etc.


Context class in android
Context class in Android define specialized listeners, which register callbacks for specific behavior when an event occurs. For example, to listen for clicks on a View control, the developer must call the

  • A Context has a lot of functions, but as a developer, you primarily use it to load and access application resources.

  • You can think of Context, like the end-user-interface that will use that code. When you are in a class you can know based on Context if you have visual screen(Activity), or a running service(Service).

  • To compare against some other programming example, you can think of Context is equal to Console App, GUI App, or even Applet.


  • Context object also provides access to: define specialized listeners, which register callbacks for specific behavior when an event occurs. For example, to listen for clicks on a View control, the developer must call the

  • API for working with database files (not DB functionality!)

  • API for working with files and directories

  • API for working with permissions

  • API for binding to services and starting/stopping them

  • API for working with cache

  • API for working with OBBs

  • API for getting strings and formatted text from package resources

  • API for getting various data relevant to the current package

  • API for working with the current Theme (see Resources.Theme)

  • Method for retrieving system services (all …Managers are retrieved through it)

  • API for handling broadcasts

  • API for starting and stopping activities

  • Method for starting Instrumentation object

  • ApplicationInfo object for the application

  • Context object associated with the current application process

  • ClassLoader object associated with the package

  • ContentResolver object associated with the package

  • Looper object associated with the main thread of the current process

  • Resources object associated with the package


ad