"AÑO DEL BUEN SERVIDOR AL CIUDADANO"
ESCUELA ACADÉMICA DE INGENIERÍA DE SISTEMAS Y TELEPÁTICA
ASIGNATURA
LABORATORIO DE PROGRAMACIÓN II
TEMA
Statement
AUTORES
LUZ CLARITA PEREZ DIAZ
LUZ ISELA FLORES CHIGUEL
LUZ CLARITA CHILCON SANCHEZ
DOCENTE
ING.MARCO AURELIO PORRO CHULLI
BAGUA GRANDE-UTCUBAMBA
AMAZONAS
2017
1.Definicion:
Vista
Preliminar.- Un objeto Statement se usa para enviar
sentencias SQL a la base de datos. Actualmente hay tres tipos de objetos
Statement, todos los cuales actúan como contenedores para la ejecución de
sentencias en una conexión dada: Statement, PreparedStatement que hereda de
Statement y CallableStatement que hereda de PreparedStatement. Estas estàn
especializadas para enviar tipos particulares de sentencias SQL, Un objeto
Statement se usa para ejecutar una sentencia SQL simple sin parámetros. Un
objeto PreparedStatement se usa para ejecutar sentencias SQL precompiladas con
o sin parámetros IN; y un objeto CallableStatement se usa para ejecutar un
procedimieno de base de datos almacenado. La interfase Statement suminstra
métodos básicos para ejecutar sentencias y devolver resultados. La interfase
PreparedStatement añade métodos para trabajat con los parámetros IN; y la
interfase CallableStatement añade métodos para trabajar con parameters OUT.
Creación
de objetos Statement .-Una vez establecida la conexión con una
base de datos particular, esta conexión puede usarse para enviar sentencias
SQL. Un objeto Statement se crea mediante el método de Connection
createStatement, como podemos ver en el siguiente fragmento de código.
Connection con = DriverManager.getConnection(url, "sunny",
""); Statement stmt = con.createStatement(); La sentencia SQL que
será enviada a la base de datos es alimentada como un argumento a uno de los
métodos de ejecución del objeto Statement. Por ejemplo:
ResultSet rs = stmt.executeQuery("SELECT a, b, c
FROM Table2");
Ejecución
de sentencias usando objetos Statement.- La interfase Statement
nos suministra tres métodos diferentes para ejecutar sentencias SQL,
executeQuery, executeUpdate y execute. El método a usar esta determinado por el
producto de la sentencia SQL El método executeQuery esta diseñado para
sentencias que producen como resultado un único result set tal como las
sentencias SELECT. El método executeUpdate se usa para ejecutar sentencias
INSERT, UPDATE ó DELETE así como sentencias SQL DDL (Data Definition Language)
como CREATE TABLE o DROP TABLE. El efecto de una sentencia INSERT, UPDATE o
DELETE es una modificación de una o más columnas en cero o más filas de una
tabla. El valor devuelto de executeUpdate es un entero que indica el número de
filas que han sido afectadas (referido como update count). Para sentencias
tales como CREATE TABLE o DROP TABLE, que no operan sobre filas, le valor
devuelto por executeUpdate es siempre cero. El método execute se usa para
ejecutar sentencias que devuelven más de un result set, más que un update count
o una combinación de ambos. Como es esta una característica avanzada que muchos
programadores no necesitarñan nunca se verá en su propia sección. Todos los
métodos que ejecutan sentencias cierran los objetos Resultset abiertos como
resultado de las llamadas a Statement. Esto quiere decir que es necesario
completar el proceso con el actual objeto Resulset antes de reejecutar una
sentencia Statement. Debe notarse que la interfase PreparedStatement, que
hereda los métodos de la interfase Statement, tiene sus propias versiones de
los métodos executeQuery, executeUpdate y execute. Los objetos Statement en si
mismos no contienen una sentencia SQL, por tanto debe suministrarse como un
argumento a los métodos Statement.execute. Los objetos PreparedStatement no
suministran una sentencia SQL como argumento a estos métodos puesto que ya tienen
la sentencia precompilada. Los objetos CallableStatement heredan las formas de
estos métodos de PreparedStatement. Usar un parametro de query con las
versiones de los métodos de PreparedStatement o CallableStatement producirái
una SQLException,.
Realización
de Statement.- Cuando una conexión está en modo
auto-commit, las sentencias ejecutadas son ‘comitadas’ o rechazadas cuando se
completan. Un sentencia se considera completa cuando ha sido ejecutada y se han
devuelto todos los resultados. Pare el método executeQuery, que devuelve un
único result set, la sentencia se completa cuando todas las filas del objeto
ResultSet se han devuelto. Para el método executeUpdate, un sentencia se
completa cuando se ejecuta. En los raros casos en que se llama al método execute,
de cualquier modo, no se completa hasta que los result sets o update counts que
se generan han sido devueltos. Algunos DBMS tratan cada sentencia en un
procedimiento almacenado como sentencias separadas. Otros tratan el
procedimiento entero como una sentencia compuesta. Esta diferencia se convierte
en importante cuando está activo el modo auto-commit porque afecta cuando se
llama al método commit. En el primer caso, cada sentencia individual es
commitada. En el segundo, se commiten todas juntas.
Cerrar
objetos Statement.- Los objetos Statement se cerrarán
automáticamente por el colector de basura de Java (garbage collector). No
obstante se recomienda como una buena práctica de programación que se cierren
explicitamente cuando no sean ya necesarios. Esto libera recursos DBMS
inmediatamente y ayuda a evitar potenciales problemas de memoria.
Sintaxis
de Escape SQL en objetos Statement.- Los objetos Statement
pueden contener sentencias SQL que usen sintaxis de escape SQL. La sintaxis de
escape señala al driver que el código que lleva debe ser tratado
diferentemente. El driver buscará por cualquier sintaxis de escape y lo
traducirá en código que entiende la base de datos en particular. Esto hace que
la sintaxis de escape sea independiente de la DBMS y permite al programador
usar características que de otro modo no estarían disponibles. Una clausula de
escape se enmarca entre llaves y tiene una palabra clave:
{keyword . . . parameters . . . }
La palabra clave (keyword) indica el tipo de clausula de
escape, según se muestra:
• escape para
caracteres LIKE
Los caracteres “%” y “_” trabajan como wildcards en la
clausula SQL LIKE
(“%” significa cero o más caracteres y “_” significa
exactamente un carácter”.
En orden a interpretarlos literalmente, pueden estar precedidos
por un
backslash (‘\’), que es un carácter de escape especial en
cadenas. Se puede
especificar un carácter que se use como carácter de
escape por la inclusión
de la sintaxis siguiente al final de la consulta.
{escape 'escape-character'}
Por ejemplo, la siguiente query, usando backslash como
caracter de escape,
encuentra nombres de identificador que comiencen con ‘_’.
stmt.executeQuery("SELECT name FROM Identifiers
WHERE Id LIKE `\_%' {escape `\'};
• fn para
funciones escalares
Casi todas las DBMS tienen funciones numèricas, de
cadena, de fecha y
conversión sobre valores escalares. Una de estas
funciones puede usarse
colocándola en la sintaxis de escape con la clave fn
seguida del nombre de
la función deseada y sus argumentos. Por ejemplo, para
llamar a la función
concat con dos argumentos que serán concatenados:
{fn concat("Hot", "Java")};
El nombre del usuario actual de la base de datos puede
obtenerse mediante:
{fn user()};
Las funciones escalares pueden estar soportadas por diferentes
DBMS con
ligeras diferencias de sintaxis, y pueden no estar
disponibles en todos los
drivers. Varios métodos de DatabaseMetaData nos listarán
las funciones
que están soportadas. Por ejemplo, el método
getNumericFunctions devuelve
una lista de los nombres de las funciones numéricas
separadas por comas, el
método getStringFunction nos devuelve los nombres de las
funciones de
cadena, y así varías más.
EL driver o bien mapeará la llamada a la función
‘escapada’ en su propia
sintaxis o implementará la función el mismo.
• d,
t y ts para literales de fecha y tiempo
Las DBMS difieren en la sintaxis que usan para los
literales de fecha, tiempo
y timestamp. JDBC soporta un formato estándar ISO para
estos literales y
usa una clausula de escape que el driver debe traducir a
la representación
del DBMS.
Por ejemplo, una fecha se especifica en SQL JDBC mediante
la sintaxis:
{d `yyyy-mm-dd'}
En esta sintaxis, yyyy es el año, mm es el mes y dd es el
dia. El driver
reemplazará la clausula de escape por la representaciòn
propia equivalente
de la DBMS. Por ejemplo, el driver reemplazaría {d
1999-02-28} por ’28-
FEB-99’ si este es el formato apropiado para la base
subyacente.
Hay clausulas de escape análogas para TIME y TIMESTAMP
{t `hh:mm:ss'}
{ts `yyyy-mm-dd
hh:mm:ss.f . . .'}
La parte fraccional de los segundos (.f . . .) del
TIMESTAMP puede
omitirse.
•
call ó ? = call para procedimientos almacenados
Si una database soporta procedimientos almacenados, estos
pueden ser
invocados desde JDBC mediante:
{call procedure_name[(?, ?, . . .)]}
o, cuando el procedimiento devuelve como resultado un
parámetro
{? = call procedure_name[(?, ?, . . .)]}
Los corchetes indican que el material encerrado en ellos
es opcional. Estos
no forman parte de la sintaxis.
Los argumentos de entrada pueden ser bien literales, bien
parámetros. Ver la
sección 7 “CallableStatement” de esta guía.
Se puede llamar al método
DatabaseMetaData.supportsStoredProcedures para ver si la
base de
datos soporta procedimientos almacenados.
• oj
para joins de salida
La sintaxis para un outer join es:
{oj outer-join}
donde outer-join es de la forma:
table LEFT OUTER JOIN {table | outer-join} ON
search-condition
Las Outer joins son una característica avanzada, y solo
puede chequearse la
gramática SQL mediente una explicación de ella. JDBC
provee tres métodos
de DatabaseMetaData para determinar que tipos de outer
joins soporta un
driver: supportsOuterJoins, supportsFullOuterJoins, y
supportsLimitedOuterJoins.
El método Statement.setEscapeProcessing activa o
desactiva el
procesamiento de escape. Por defecto la característica se
encuentra activada. Un
programador debería desactivar esta característica en
tiempo de ejecución cuando
el rendimiento ha de ser máximo, pero normalmente debe
estar activado. Debería
notarse que setEscapeProcesing no trabaja con objetos
PreparedStatement
por que la sentencia ya está preparada para enviar a la
base de datos antes de
poder ser llamada.
4.1.6
Uso del método execute
El método execute debería usarse solamente cuando es
posible que una sentencia
nos devuelva más de un objeto Resultset., mas de un
update count o una
combinación de ambos. Estas múltiples posibilidades para
resultados, aunque raras,
son posibles cuando se ejecutan ciertos procedimientos
almacenados o por la
ejecución dinámica de una string SQL desconocida (esto
es, desconocida para el
programador de la aplicación en tiempo de compilación).
Por ejemplo, una usuario
podría ejecutar un procedimiento almacenado (usando una
objeto
CallableStatement y este procedimiento podría ejecutar
una actualización,
después una select, luego una actualización, después una
select y así.
Normalmente, alguien que usa un procedimiento almacenado
sabrá que se le va a
devolver.
Porque el método execute maneja los casos que se salen de
lo ordinario, no
sorprende que los resultados devueltos requieren algun
manejo especial. Por
ejemplo, supongamos que se sabe que el procedimiento
devuelve dos result sets.
Después de usar el método execute para ejecutar el
procedimiento, se debe llamar
al método getResultSet para conseguir el primer result
set y después los
métodos apropiados getXXX para recuperar los valores de
él. Para conseguir el
segundo result set, se necesita llamar al método
getMoreResults y y despues a
getResultSet
de nuevo. Si se sabe que el procedimiento devuelve dos upadte
counts, se llama primero al método getUpdateCount,
seguido de
getMoreResults y de nuevo getUpdateCount.
Aquellos casos en los que no se conoce que devolverá se
nos presenta una
situación más compleja. El método execute devuelve true
si el resultado es un
objeto ResultSet y false si es un int Java. Si devuelve
un int, esto quiere
decir que el resultado o bien es un update count o que la
sentencia que ha
ejecutado es un comando DDL. Lo primero que hay que hacer
después de llamar
execute es llmar o bien a getResultSet o getUpdateCount.
Al método
getResultSet se le llama para conseguir el primero de los
dos o más objetos
ResultSet y al método getUpdateCount para conseguir el
primero de dos o más
update counts.
Cuando el resultado de una sentencia SQL no es un result
set, el método
getResultSet devolverá null. Esto quiere decir que el
resultado es un update
count o que no hay más resultados. La única manera de
encontrar que significa el
valor null en este caso es llamar al método
getUpdateCount, que devolverá un
entero. Este entero será el número de filas afectadas por
la sentencia ejecutada o
–1 para indicar o bien que el resultado es un result set
o bien que no hay más
resultados. Si el método getResultSet ya ha devuelto
null, el resultado no puede
ser un objeto ResultSet, por lo que el valor devuelto de
–1 tiene que ser que no
hay más resultados. En otras palabras, no hay más
resultados cuando lo siguiente
es cierto:
((stmt.getResultSet() == null) && (stmt.getUpdateCount()
== -1))
Si se ha llamado al método getResultSet y se ha procesado
el objeto
ResultSet devuelto, es necesario llamar al método
getMoreResults para ver si
hay más result sets o update counts.. Si getMoreResults
devuelve true, entonces
es necesario llamar de nuevo a getResultSet para
recuperar el siguiente result
set. Como ya se ha indicado anteriormente, si
getResultset devuelve null hay
que llamar a GetUpdateCount para buscar que significa ese
null si un update
count o que no hay más resultados.
Cuando getMoreResults devuelve false quiere decir que la
sentencia SQL ha
devuelto un update count o que no hay más resultados. Por
tanto es necesario
llamar al método getUpdateCount para encontrar cual es el
caso. En esta situación,
no habrá más resultados cuando lo siguiente es cierto:
((stmt.getMoreResults() == false) &&
(stmt.getUpdateCount() == -1))
El siguiente código muestra una forma de asegurarse que
se ha accedido a todos
los result sets y update counts de una llamada al método
execute:
stmt.execute(queryStringWithUnknownResults);
while (true) {
int rowCount =
stmt.getUpdateCount();
if (rowCount >
0) { // this is an update count
System.out.println("Rows changed = "
+ count);
stmt.getMoreResults();
continue;
}
if (rowCount == 0)
{ // DDL command or 0 updates
System.out.println(" No rows changed or
statement was DDL
command");
stmt.getMoreResults();
continue;
}
// if we have
gotten this far, we have either a result set
// or no more
results
ResultSet rs =
stmt.getResultSet;
if (rs != null) {
. . . // use
metadata to get info about result set columns
while (rs.next())
{
. . . // process
results
stmt.getMoreResults();
continue;
}
break; // there
are no more results
Propiedades (C# y Java)
En C#, una propiedad es un miembro con nombre de una
clase, estructura o interfaz que ofrece una forma ordenada de tener acceso a
campos privados mediante lo que se denomina métodos de descriptor de accesoget y set.
En el ejemplo de código siguiente declara una propiedad
denominada Species para la clase Animal, que resume el acceso a
la variable privada denominada name:
C#
public class Animal
{
private string
name;
public string
Species
{
get
{
return
name;
}
set
{
name =
value;
}
}
}
A menudo, la propiedad tendrá el mismo nombre que el
miembro interno al que tiene acceso, pero con una letra mayúscula inicial, por
ejemplo, Nameen el caso anterior o el miembro interno tendrá un prefijo _.
Observe también el parámetro implícito denominado value que se
utiliza en el descriptor de acceso set; éste tiene el tipo de la
variable miembro subyacente.
De hecho, los descriptores de acceso se representan en
forma interna como métodos get_X() y set_X() para mantener
la compatibilidad con los lenguajes basados en .NET Framework, que no admiten
descriptores de acceso. Una vez que una propiedad está definida, es muy fácil
obtener o establecer su valor:
C#
class TestAnimal
{
static void
Main()
{
Animal
animal = new Animal();
animal.Species = "Lion";
// set accessor
System.Console.WriteLine(animal.Species); // get accessor
}
}
Si una propiedad sólo tiene un descriptor de acceso get,
es una propiedad de sólo lectura. Si sólo tiene un descriptor de acceso set,
es una propiedad de sólo escritura. Si tiene ambos, es una propiedad de lectura
y escritura.
Structs (C# y Java)
C# admite la palabra clave struct,
que es otro elemento que se origina en C pero no está disponible en Java. struct se
puede considerar como una clase ligera. Aunque las structs pueden
contener constructores, constantes, campos, métodos, propiedades, indizadores,
operadores y tipos anidados, se utilizan principalmente para encapsular grupos
de campos relacionados. Dado que las estructuras son tipos de valor, se pueden
asignar de un modo ligeramente más eficaz que las clases. Las structs difieren
de las clases en que no pueden ser abstractas y no admiten la herencia de
implementaciones.
En el ejemplo siguiente, se inicializa struct con
la palabra clave new, se
llama al constructor predeterminado sin parámetros y, a continuación, se
establecen los miembros de la instancia.
C#
public struct Customer
{
public int ID;
public string
Name;
public
Customer(int customerID, string customerName)
{
ID =
customerID;
Name =
customerName;
}
}
class TestCustomer
{
static void Main()
{
Customer c1
= new Customer(); //using the default
constructor
System.Console.WriteLine("Struct values before
initialization:");
System.Console.WriteLine("ID = {0}, Name = {1}", c1.ID,
c1.Name);
System.Console.WriteLine();
c1.ID =
100;
c1.Name =
"Robert";
System.Console.WriteLine("Struct values after
initialization:");
System.Console.WriteLine("ID = {0}, Name = {1}", c1.ID,
c1.Name);
}
}
Resultado
Cuando se compila y ejecuta el código anterior, el
resultado muestra que las variables struct se inicializan de
manera predeterminada. La variable int se
inicializa en 0 y la variable string se
inicializa en una cadena vacía:
Struct values before initialization:
ID = 0, Name =
Struct values after initialization:
ID = 100, Name = Robert
Ejemplos
Especificar características
de ResultSet
Las características de los ResultSets
están asociadas con la sentencia que finalmente los crea. El método
Connection.createStatement permite especificar estas características de
ResultSet. A continuación se ofrecen algunos ejemplos de llamadas válidas al
método createStatement:
Ejemplo: método
createStatement
// El siguiente código es nuevo en JDBC
2.0
Statement stmt2 =
conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATEABLE);
// El siguiente código es nuevo en JDBC
3.0
Statement stmt3 =
conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY,
ResultSet.HOLD_CURSOR_OVER_COMMIT);
Este es un ejemplo de utilización del método
executeUpdate del objeto Statement.
Nota
Utilizando los códigos de ejemplo, acepta los términos
de Información
de licencia de código y declaración de limitación de responsabilidad.
import java.sql.*;
import java.util.Properties;
public class StatementExample {
public static
void main(java.lang.String[] args)
{
//
Sugerencia: estos se cargan a partir de un objeto de propiedades.
String
DRIVER = "com.ibm.db2.jdbc.app.DB2Driver";
String
URL = "jdbc:db2://*local";
//
Registrar el controlador JDBC nativo. Si el controlador no puede
//
registrarse, la prueba no puede continuar.
try {
Class.forName(DRIVER);
} catch
(Exception e) {
System.out.println("Imposible registrar el controlador.");
System.out.println(e.getMessage());
System.exit(1);
}
Connection
c = null;
Statement s
= null;
try {
//
Crear las propiedades de conexión.
Properties properties = new Properties ();
properties.put ("user", "userid");
properties.put ("password", "password");
//
Conectar con la base de datos local de iSeries.
c =
DriverManager.getConnection(URL, properties);
//
Crear un objeto Statement.
s = c.createStatement();
// Se
suprime la tabla de prueba, si existe. Observe que
// en
este ejemplo se presupone que la colección MYLIBRARY
//
existe en el sistema.
try {
s.executeUpdate("DROP TABLE MYLIBRARY.MYTABLE");
} catch
(SQLException e) {
//
Se continúa simplemente... es probable que la tabla no exista.
}
// Se
ejecuta una sentencia SQL que crea una tabla en la base de datos.
s.executeUpdate("CREATE TABLE
MYLIBRARY.MYTABLE (NAME VARCHAR(20), ID INTEGER)");
// Se
ejecutan algunas sentencias SQL que insertan registros en la tabla.
s.executeUpdate("INSERT INTO MYLIBRARY.MYTABLE (NAME, ID) VALUES
('RICH', 123)");
s.executeUpdate("INSERT INTO MYLIBRARY.MYTABLE (NAME, ID) VALUES
('FRED', 456)");
s.executeUpdate("INSERT INTO MYLIBRARY.MYTABLE (NAME, ID) VALUES
('MARK', 789)");
// Se
ejecuta una consulta SQL en la tabla.
ResultSet rs =
s.executeQuery("SELECT * FROM MYLIBRARY.MYTABLE");
//
Visualizar todos los datos de la tabla.
while
(rs.next()) {
System.out.println("El empleado " + rs.getString(1) + "
tiene el ID " + rs.getInt(2));
}
} catch
(SQLException sqle) {
System.out.println("El proceso de base de datos ha fallado.");
System.out.println("Razón: " + sqle.getMessage());
} finally {
// Se
cierran los recursos de base de datos.
try {
if
(s != null) {
s.close();
}
} catch
(SQLException e) {
System.out.println("El borrado no ha podido cerrar
Statement.");
}
}
try {
if
(c != null) {
c.close();
}
} catch
(SQLException e) {
System.out.println("El borrado no ha podido cerrar Connection.");
}
}
}
}
2. RESUMEN
STATEMENT - JAVA.SQL.STATEMENT:
java.sql.Statement
Se usa para ejecutar sentencias SQL.
Lleva asociada una conexión que
sirvió como origen para su creación.
· Se
crea con el método de la clase:
java.sql.Connection:
public Statement createStament()
trows java.sql.SQLException;
· Las
sentencias se cierran con el método:
public void close() trows
java.sql.SQLException;
El método para ejecutarla depende del
tipo de sentencia SQL que contenga.
Sentencias SELECT:
Se usa el método: executeQuery(String
sql). Devuelve una instancia de java.sql.ResultSet.
Sentencias INSERT, UPDATE,
DELETE:
Se usa el método:
executeUpdate(String sql).devuelve un int con el número de filas afectadas
3. SUMMARY
STATEMENT - java.sql.Statement:
java.sql.Statement
It is used to execute SQL statements.
It is associated with a connection
that served as the source for its creation.
• is created with the method of the
class:
java.sql.Connection:
Statement public createStament ()
trows java.sql.SQLException;
• The sentences are closed with the
method:
public void close () trows
java.sql.SQLException;
The method to execute depends on the
type of SQL statement containing.
SELECT statements:
executeQuery (String sql) method is
used. Returns an instance of java.sql.ResultSet.
INSERT, UPDATE, DELETE:
the method is used: executeUpdate
(String sql) .devuelve an int with the number of rows affected
Ø Un objeto Statement se
debe crear, mediante el método de Connection createStatement
Ø Un objeto Statement solo, es
usado para ejecutar una sentencia SQL simple sin parámetros.
Ø Un objeto
PreparedStatement se usa para ejecutar sentencias SQL precompiladas con o sin
parámetros IN.
Ø Un objeto CallableStatement se
usa para ejecutar un procedimiento de base de datos almacenado.
3. CONCLUSIONES
Ø Para el método de conexión se utilizan los siguientes
componentes: Connection, Statement y ResultSet.
Ø El Statement es el que genera el comando de
ejecución, para ello todo este comando lo mandamos en el parámetro SQL.
6. APRECIACIÓN
DEL EQUIPO
Ø Nuestra apreciación con
respecto al trabajo realizado, sobre el tema deStatement es que
Statement es un objeto que es usado para enviar sentencias SQL a la base de
datos, actualmente hay tres tipos de objetos Statement, todos los cuales actúan
como contenedores para la ejecución de sentencias en una conexión dada:
Statement, PreparedStatement y CallableStatement.
Ø Esperamos que este
trabajo le sea útil a la persona interesadas.
7. GLOSARIO
· MÉTODO.- Un método en Java es un conjunto de
instrucciones definidas dentro de una clase, que realizan una determinada tarea
y a las que podemos invocar mediante un nombre.
· CONTENEDOR.- Se trata de unidades estancas que protegen las
mercancías de la climatología.
· PARÁMETROS.- Variable que establece un conjunto de
características a ser reproducidas dentro de un patrón establecido por un
programa o lenguaje dados.
· INTERFACE.- es el conjunto
de subrutinas, funciones y procedimientos (o métodos, en la programación
orientada a objetos) que ofrece cierta biblioteca para ser utilizado por otro
software como una capa de abstracción.
· SINTAXIS.-
Forma correcta en que deben estar dispuestos los símbolos que componen una
instrucción ejecutable por el ordenador.
· OBJETO.-entidad existente en la memoria del
ordenador que tiene unas propiedades (atributos o datos sobre sí mismo
almacenados por el objeto) y unas operaciones disponibles específicas
(métodos).
8. LINKOGRAFIA
ahí les dejo algunas diapositivas en ese link espero les guste.
https://www.slideshare.net/LUZCLARITAPEREZDIAZ/statement-80876117
No hay comentarios:
Publicar un comentario