Question

I am new to Xcode and iOS development. when I create a new project, automatically Xcode create many files ended with:
AppDelegate.h
AppDelegate.m
mainwindow.xlib
ViewController.h
ViewController.m
ViewController.xlib

What are these files?

Answer 1

You should reference The Core Application Objects section of the Core Application Design.

The role of objects in an iOS
application

UIApplication object (AppDelegate Related)

The UIApplication object manages the
application event loop and coordinates
other high-level behaviors for your
application. You use this object as
is, mostly to configure various
aspects of your application’s
appearance. Your custom
application-level code resides in your
application delegate object, which
works in tandem with this object.
Application delegate object The
application delegate is a custom
object that you provide at application
launch time, usually by embedding it
in your application’s main nib file.
The primary job of this object is to
initialize the application and present
its window onscreen. The UIApplication
object also notifies this object when
specific application-level events
occur, such as when the application
needs to be interrupted (because of an
incoming message) or moved to the
background (because the user tapped
the Home button). For more information
about this object, see “The
Application Delegate.”

Data model objects (These will be available when you include CoreData in your project)

Data model objects store your
application’s content and are
therefore specific to your
application. For example, a banking
application might store a database
containing financial transactions,
whereas a painting application might
store an image object or even the
sequence of drawing commands that led
to the creation of that image. (In the
latter case, an image object is still
a data object because it is just a
container for the image data. The
actual rendering of that image still
takes place elsewhere in your
application.)

View controller objects (ViewController.h and ViewController.m are your source files and ViewController.xib is your interface builder file)

View controller objects manage the
presentation of your application’s
content. Typically, this involves
creating the views to present that
content and managing the interactions
between the views and your
application’s data model objects. The
UIViewController class is the base
class for all view controller objects.
It provides default functionality for
animating the appearance of views,
handling device rotations, and many
other standard system behaviors. UIKit
and other frameworks also define other
view controller classes for managing
standard system interfaces, such as
navigation interfaces or the image
picker. For detailed information about
how to use view controllers, see View
Controller Programming Guide for iOS.

UIWindow object (mainwindow.xib is the interface builder file that links your window and other objects together with your AppDelegate)

A UIWindow object coordinates the
presentation of one or more views on
the device screen or on an external
display. Most applications have only
one window, the content of which is
provided by one or more views. An
application changes the content of
that window by changing the current
set of views (usually with the help of
a view controller object). In addition
to hosting views, windows are also
responsible for delivering events to
those views and to their managing view
controllers.

View, control, and layer objects (These will belong to your view controllers)

Views and controls provide the visual
representation of your application’s
content. A view is an object that
draws content in a designated
rectangular area and responds to
events within that area. Controls are
a specialized type of view responsible
for implementing familiar interface
objects such as buttons, text fields,
and toggle switches. The UIKit
framework provides standard views for
presenting many different types of
content. You can also define your own
custom views by subclassing UIView (or
its descendants) directly. In addition
to incorporating views and controls,
applications can also incorporate Core
Animation layers into their view and
control hierarchies. Layer objects are
actually data objects that represent
visual content. Views use layer
objects intensively behind the scenes
to render their content. You can also
add custom layer objects to your
interface to implement complex
animations and other types of
sophisticated visual effects.