UNIVERSIDAD TÉCNICA DE MANABÍ

FACULTAD DE CIENCIAS INFORMÁTICAS

CARRERA DE INGENIERÍA EN SISTEMAS

Alumno:

Vélez Sánchez José Manuel

Tema:

POLIMORFISMO – HERENCIA Y PROGRAMACIÓN

GRAFICA EN JAVA

Fecha:

22-01-2013

Curso:

3 “C”

Docente:

Ing. Danny Jarre

Periodo académico

Sept 2012 – enero 2013

FACULTAD DE CIENCIAS INFORMÀTICAS

MISIÓN:

Ser una unidad con alto prestigio académico, con eficiencia, transparencia y calidad en la

educación, organizada en sus actividades, protagonistas del progreso regional y nacional.

VISIÓN:

Formar profesionales eficientes e innovadores en el campo de las ciencias informáticas, que

con honestidad, equidad y solidaridad, den respuestas a las necesidades de la sociedad

elevando su nivel de vida.

INHERITANCE

Inheritance is a mechanism that allows the definition of a class from an existing definition.

Inheritance allows automatically share methods and data between classes, subclasses and

objects.

Inheritance is strongly related to code reuse in OOP. That is, the code of any class can be

used no more than create a class derived from it, or a subclass.

There are two types of single and multiple inheritance. Single means only inherit from a

base class, while we have several shows multiple base classes (eg inherits a seaplane and

boat tickets). Java only supports single inheritance.

STATEMENT

To indicate that a class derived from another, inheriting properties (attributes and

methods) extends the term is used, as in the following example:

public class SubClass extends SuperClass

{

/ / Class Content

}

For example, create a class MiPunto3D, daughter Mipunto class as shown:

Mipunto MiPunto3D class extends {

int z;

MiPunto3D () {

x = 0; / / Inherited from Mipunto

y = 0; / / Inherited from Mipunto

z = 0; / / New Attribute

}

}

The extends keyword is used to say that we want to create a subclass of the class that is

named below, in our case is MiPunto3D Mipunto daughter.

POLYMORPHISM

Polymorphism is a concept of object-oriented programming that allows us to program in

general, rather than specifically. Overall we used to program objects with common

characteristics and that all these share the same superclass in a class hierarchy, as if they

were all objects of the superclass. This simplifies programming us.

Remember the example of the ecosystem, where all objects of different species inherited

from a superclass called Animal, which provided an overview of any animal, regardless of

species. However, each kind of particular use for each of the methods or operations

class is

{

CalcularPerimetro ();

}

Now we derive two classes of the class is, one is rectangle, and a pentagon.

Class :: rectangle shape

{

CalcularPerimetro ();

}

Class :: pentagon shape

{

CalcularPerimetro ()

}

Rectangle and Pentagon are ways, but each calculates its perimeter differently, so each

has its perimeter function.

Now imagine you have a variable of type form:

object form;

Well, polymorphism says you can do this:

object = devolverForma ();

objeto.CalcularPerimetro ();

devolverForma () can return a rectangle, pentagon or an object, you do not know which of

the two things will return, and you do not care, you just call CalcularPerimetro, and

whether it is a pentagon or a rectangle, you use function correct (the Pentagon or the

rectangle).

That is polymorphism.

GRAPHIC PRORAMACION

INTRODUCTION

The user interface is the part of the program that allows it to interact with the user. User

interfaces can take many forms, ranging from simple command line to graphical user

interfaces (GUI-GUI) that provide the latest software. The user interface is one of the most

important aspects of any application. An application without a user-friendly interface, it

prevents users get the most from the program. Java provides the basic elements for

building user interfaces through the AWT class library, and options for improvement

through a new library called Swing. Because the Java programming language is

independent of the platform on which to run their applications, the AWT library is also

independent of the platform on which it runs. The AWT provides a toolkit for building

graphical interfaces that look and behave similarly on all platforms on which to run. The

interface elements provided by the AWT library are implemented using native toolkits

platforms, preserving an appearance similar to all applications that are created for that

platform. This is a strength of the AWT, but also has the disadvantage that a graphical

interface designed for one platform can not display properly in a different one. These

deficiencies are remedied AWT Swing in part, and in general by the JFC (JavaFoundation

Classes).

AWT (Abstract Window Toolkit)

AWT is the acronym for Java Abstract Window Toolkit. This is a Java class library for

developing graphical user interfaces. The AWT version that Sun provides the JDK 1.0.x

developed in only two months and is the weakest part of everything that represents Java

as a language.

GUI INTERFACE

We call GUI GUI (Graphical User Interface) to the set of graphical components that allow

interaction between the user and the application. Ventnas ie, buttons, combos, lists,

dialog boxes, text fields, etc.

First we have to design the application, and finally programmed events that are

generated as the user interacts with the interface.

Components are objects of classes that inherit from the base class component like

Button, List, TextField, TextArea, Label, etc..

In a GUI components are contained in containers or containers. A containes is an object

whose class inherits from Container (class which in turn is subclass of Component) and has

the responsibility for containing components.

Usually a GUI is mounted on a frame. This will be the main Container containing the

components of the GUI, a Container can contain other containers.

Distribution of components (layouts)

The containers containing components and these are arranged in the visual space of the

container respetanto unaa some call distribution layout.

AWT and Swing

Java provides two API's with which we can work to develop GUIs, the most basic is AWT

(Abstrct Window Toolkit). The most developed are made with Swing, which are

identifiable because they all begin with "J", eg JButton, JTextField, JTextArea, JFrame and

JPanel are Swing classes.

All layouts and event handling is exactly the same for AWT and Swing.

Relative distributions

The layouts determine the criterion by which to distribute vaan components within the

container

FlowLayout: distributes the components beside each other in the upper container. By

default provides a center alignment, but also can align to the left or right.

BorderLayout: Divide the space of the container in 5 regions: NORTH, SOUTH, EAST, WEST

and CENTER, supports a single component by region

GridLayout: Divide the space of the container into a grid of n rows by m columns, where

the cells are of equal size

GridBagLayout: Divide the space of the container into a grid where each component can

span multiple rows and columns. In addition to distribute the internal space of each cell.

To draw need an instance of the Graphics class. This class must be associated to the

component on which we draw to draw on it. For an instance of this class of a

componentel, simply ask the component in which we draw a Graphics. E.g.

Canvas canvas = new Canvas ();

Graphics g = lienzo.getGraphics ();

g.drawLine (...);

The Graphics class has methods of drawing style drawLine (), drawRectangle (), etc.. Since

that we have obtained the Graphics Canvas, what you draw with the Graphics will be

drawn on the Canvas. The problem is that this will not work well. When component (the

Canvas), need repainting, because it passes over another window, because we minimize it

and then we maximize or for whatever reason, do not redraw our drawing.