Академический Документы
Профессиональный Документы
Культура Документы
Minatitlán
Fundamentos de Programación
Cuestionario Unidad 5
02/06/2008
1. Define el concepto de clase, ilustre su implementación y
de 5 ejemplos de ellos.
class Nombre {
// Variables miembro (habitualmente privadas)
miembro_1; //lista de miembros
miembro_2;
miembro_3;
METHOD Metodo
Propiedades
Las propiedades son un tipo especial de métodos. Debido a que suele ser
común que las variables miembro sean privadas para controlar el acceso y
mantener la coherencia, surge la necesidad de permitir consultar o
modificar su valor mediante pares de métodos: GetVariable y SetVariable.
Los lenguajes orientados a objetos más modernos (por ejemplo Java, C#)
añaden la construcción de propiedad que es una sintaxis simplificada para
dichos métodos:
tipo Propiedad {
get {
}
set {
}
}
...
public
prívate
protected
Public
Private
El acceso mas restrictivo es private. Las clases del nivel mas alto no
pueden ser declaradas privadas ya que haría imposible el acceso a
ningún método o variable de esta. Un método o variable privada solo
puede ser instanciado en la clase que lo declara. Las variables y
métodos privados solo pueden ser accedidos por una instancia de la
clase que las declara ya que los modificadores de acceso indican que
clases, no que instancias pueden acceder a sus características. Las
subclases tampoco pueden acceder a variables y métodos privados.
Las clases, métodos y variables con acceso defecto solo pueden ser
accedidos por clases que se encuentran dentro del mismo paquete.
Protected
Java especifica que los métodos no pueden ser sobrescritos para ser más
privados, esto quiere decir que cuando heredamos y realizamos una
sobrecarga o una sobrescritura, el acceso nunca puede ser más
restrictivo. Cualquier método que sea sobrescrito con un acceso más
restrictivo producirá un error de compilación.
Un método por defecto puede ser sobrescrito por un método por defecto,
protegido o público.
Otros modificadores
final
abstract
static
Esto quiere decir que para una variable animales existe solo una variable
animales para todas las instancias de la clase. Se puede hacer referencia
a una variable estática mediante una instancia de la clase o mediante el
nombre de la clase.
Los métodos al igual que los datos, pueden ser declarados estáticos. Los
métodos estáticos solo pueden utilizar características estáticas y llamar
a métodos estáticos. Estos pueden ser invocados incluso antes de que
alguna instancia de la clase sea construida.
Inicializadores estáticos
Es legal para una clase contener código estático fuera del método de un
cuerpo. Una clase puede tener un bloque de código de inicialización
simplemente rodeado de llaves con la palabra estatic.
public class Gallina {
static {
System.out.println("Programa.");
native
Este modificador solo puede referirse a métodos, indica que el cuerpo de
un método se encuentra fuera de la máquina virtual de Java, en una
librería. El código nativo esta escrito en otro lenguaje de programación,
típicamente C o C++ y compilado para una sola plataforma por lo que la
independencia de plataforma de Java es violada cuando utilizamos este
tipo de métodos.
transient
Cuando hay cierta información que no se desea enviar como parte del
objeto, como puede ser cierta información delicada que quizás por
razones de seguridad no deben ser enviadas a través de un canal
inseguro (una contraseña), se declara transient y esta no es escrita
durante la serialización.
synchronized
Modificador public
class dado{
public $puntos;
function __construct(){
srand((double)microtime()*1000000);
}
for ($i=0;$i<30;$i++){
$mi_dado->tirate();
echo "<br>Han salido " . $mi_dado->puntos . " puntos";
}
// protected_public.cs
// Public access
using System;
class Point
{
public int x;
public int y;
}
class MainClass
{
static void Main()
{
Point p = new Point();
// Direct access to public members:
p.x = 10;
p.y = 15;
Console.WriteLine("x = {0}, y = {1}", p.x, p.y);
}
public class:
public class Tricycle
{
// protected method:
protected void Pedal() { }
// private field:
private int m_wheels = 3;
namespace System.IO
{
public class Stream {...}
public class FileStream: Stream { ... }
...
}
Assembly A2.dll
namespace EnsambladoGuille
{
public class GuilleStream : Stream {...}
}
using System.IO;
using EnsambladoGuille;
class Program
{
static void Main()
{
Stream s = new GuilleStream();
...
}
}
Ejemplo:
class Employer //nombre de clase
{
public string name="xxx"; //Declaracion de
private double salary=1000.00; //variables con modificador
public double AccesSalary() //public y privated
{
return salary;
}
}
class Mainclass
{
public static void Main()
{
Employer E = new Employer(); //creacion de objeto
string n = E.name;
double s = E.Acces
Console.WriteLine(" nombre:{0}",n); //Despliegue de
Console.WriteLine(" salario:{0}",s); //datos
Console.ReadLine();
}
class dado{
private $puntos;
function __construct(){
srand((double)microtime()*1000000);
}
package privateTest
{
import flash.util.trace
}
}
// public class:
public class Tricycle
{
// protected method:
protected void Pedal() { }
// private field:
private int m_wheels = 3;
Modificador protected
Este indica un nivel de acceso medio y un poco más especial que los
anteriores. Sirve para que el método o atributo sea público dentro del
código de la propia clase y de cualquier clase que herede de aquella donde
está el método o propiedad protected. Es privado y no accesible desde
cualquier otra parte. Es decir, un elemento protected es público dentro de
la propia clase y en sus heredadas.
package privateTest
{
import flash.util.trace
class B : A
{
public B()
{
}
private string _text = "Adiós";
private int _count = 0;
new public string Text
{
get { return _text; }
protected set { _text = value; }
}
new protected int Count
{
get { return _count; }
set { _count = value; }
}
}
}
class Empleado {
protected int sueldo;
...
}
package package2;
class AccesoPorPaquete{
void accederAUnMiembro(){
ClaseConMiembroProtegido cc = new
ClaseConMiembroProtegido();
System.out.println(cc.demeAlgo());
}
}
a = b + c; //objeto encapsulado
dato.readLine();
System.out.println(“Introduce el valor de c”);
dato.readLine();
public Rectangulo (double p1x, double p1y, double p2x, double p2y) {
x1 = p1x;
x2 = p2x;
y1 = p1y;
y2 = p2y;
y direccionalidad:
Composición
class Cubo {
double ancho;
double alto;
double largo;
void volumen(){
System.out.print("Volumen igual a : ");
System.out.println(ancho * alto * largo);
}
}
// esta clase declara un objeto de tipo Cubo
class CuboDemo{
class Cubo {
double ancho;
double alto;
double largo;
double volumen(){
return(ancho * alto * largo);
}
class CuboDemo{
a+1 = b;
Categorías sintácticas
Las reglas gramaticales que constituyen la sintaxis de un lenguaje se basan
en la existencia de categorías sintácticas. Por ejemplo, en
Java, instrucciones, expresiones, asignaciones, etc. son ejemplos de
categorías sintácticas de la misma forma que las proposiciones, los verbos,
los sustantivos, son categorías sintácticas en un lenguaje hablado como el
castellano.
Cuando una regla gramatical especifica que en tal contexto debe ir tal
categoría sintáctica, significa que ahí puede y debe ir cualquier
construcción del lenguaje que sea considerada de esa categoría.
Para el caso específico del lenguaje Java, las categorías sintácticas más
importantes son las siguientes:
identificadores.
constantes.
operadores binarios y unario.
expresiones.
instrucciones.
Reglas sintácticas
La sintaxis de un lenguaje permite determinar matemáticamente si un
programa es correcto desde el punto de vista sintáctico o no. Esta sintaxis
se expresa en base a un conjunto de reglas gramaticales del estilo:
exp -> exp op-bin exp
Arbol sintáctico
Una árbol sintáctico permite demostrar que una secuencia de caracteres es
una determinada categoría sintáctica. Por ejemplo, el siguiente es un árbol
sintáctico que demuestra que 'a+5' es una expresión:
a + 5
| | |
ident op-bin const
| | |
exp | exp
\ | /
\ | /
exp
Para que un árbol sintáctico sea válido se necesita que para cada
bifurcación del estilo:
sub-categorías ...
\ | /
categoría
Sin embargo, con las reglas que hemos enunciado para una expresión
hasta el momento, no podemos mostrar que '-a + b' es una expresión. El
siguiente grupo de reglas sintácticas permite enriquecer el conjunto de
frases que corresponden a expresiones:
Expresiones
ex (1
-> const
p )
(2
-> ident
)
-> op-unario (3
exp )
-> exp op-bin (4
exp )
(5
-> ( exp )
)
Operadores binarios
aritmético op- - +
s: bin >
- -
>
- *
>
- /
>
- %
>
relacional - ==
es: >
- !=
>
- >=
>
- <=
>
- >
>
- <
>
booleanos - &&
: >
- ||
>
Operadores unarios
aritmétic op- - -
os: unario >
- +
>
booleano - !
s: >
Hemos enumerado las reglas que describen lo que es una expresión para
indicar cuando se aplican en los árboles sintácticos que mostrares a
continuación:
• -a + b
• - a + 5
• | | | |
• op-unario ident op-bin const
• \ | | |
• \ exp(2)/ exp(1)
• \ / / /
• exp(3) / /
• \ / /
• --+-------
• |
• exp(4)
• a-(b-c)
• a - ( b - 5 )
• | | | | | | |
• ident op-bin | ident op-bin const |
• | | | | | | |
• exp(2) | | exp(2) | exp(1)|
• \ \ \ \ | / /
• \ \ \ ---+---- /
• \ \ \ exp(4) /
• \ \ \ | /
• \ \ -----+-------
• \ \ exp(5)
• \ \ /
• -----\----
• exp(4)
• a+-b
• a + - b
• | | | |
• ident | op-unario ident
• | | \ /
• | | \ exp(2)
• | | \ /
• exp(2) op-bin exp(3)
• \ | /
• ----|--------
• exp(4)
Del mismo modo, se puede mostrar que 'a+!b' también es una expresión.
Para ello basta cambiar el '-' por '!' en el árbol anterior. Sin embargo, aún
cuando sintácticamente se trate de una expresión bien escrita, es una
expresión incorrecta, puesto que no es posible asignarle un tipo a esta
expresión. Esto quedará más claro cuando hablemos sobre el sistema de
tipos.
Ejercicios:
-(a+-5*b)
• a + 5 c
• | | | |
• ident | const ident
• | | | |
• | | exp exp
• | | \ /
• exp | exp
• \ | /
• ---|------
• exp
Reglas de desambiguación
Precedencia
- +
(operadores
unarios)
* / %
+ -
(operadores
binarios)
== != >= <= > <
!
&& ||
Estas reglas eliminan el segundo árbol sintáctico como posible
interpretación. Java interpreta inequívocamente la expresion 'a-b*c' por
medio del primer árbol sintáctico.
• Asociatividad
La expresión de asignación
en vez de:
a= readInt();
while ( a!=0 ) {
...
a= readInt();
}
Se puede apreciar que el primer trozo de código resulta más breve que el
segundo.
Parámetros
Los parámetros se usan para mandar valores a la función, con los que
ella trabajará para realizar las acciones. Son los valores de entrada que
recibe una función. Por ejemplo, una función que realizase una suma de
dos números tendría como parámetros a esos dos números. Los dos
números son la entrada, así como la salida sería el resultado, pero eso lo
veremos más tarde.
Veamos un ejemplo anterior en el que creábamos una función para
mostrar un mensaje de bienvenida en la página web, pero al que ahora
le vamos a pasar un parámetro que contendrá el nombre de la persona a
la que hay que saludar.
function escribirBienvenida(nombre){
document.write("<H1>Hola " + nombre + "</H1>")
}
escribirBienvenida("Alberto García")
Múltiples parámetros
function pasoPorValor(miParametro){
miParametro = 32
document.write("he cambiado el valor a 32")
}
var miVariable = 5
pasoPorValor(miVariable)
document.write ("el valor de la variable es: " + miVariable)
{ cuerpo de instrucciones; };
prog13.java
import java.lang.*;
import java.io.*;
class prog13 {
double beta=3.1416;
}; // cierra main
public static void proc1(int a, double b, String nom )
double c = a + b;
}; // cierra proc1
} // cierra clase
Una solución mejor es crear un método que tome las dimensiones del
cubo dentro de sus parámetros y establezca las variables de instancia de
forma apropiada. Este concepto se implementará en el siguiente
ejemplo:
class Cubo {
double ancho;
double alto;
double largo;
double volumen(){
ancho = x;
alto = y;
largo = z;
double vol;
// Inicializa el cubo
micubo.setDim(10,20,15);
vol = micubo.volumen();
#include <stdio.h>
main()
{
int i1,i2;
i1=5; i2=105;
proc(p1,p2)
int p1;
int *p2;
{
function Caja($alto=1,$ancho=1,$largo=1,$color="negro"){
$this->alto=$alto;
$this->ancho=$ancho;
$this->largo=$largo;
$this->color=$color;
$this->contenido="";
}
En este constructor recibimos por parámetro todos los atributos que hay
que definir en una caja.
Es muy útil definir unos valores por defecto en los parámetros que recibe el
constructor, igualando el parámetro a un valor dentro de la declaración de
parámetros de la función constructora, pues así, aunque se llame al
constructor sin proporcionar parámetros, se inicializará con los valores por
defecto que se hayan definido.
class prueba
{
tipo1 d1;
tipo2 d2;
tipo3 d3;
public:
prueba(tipo1 p1, tipo2 p2, tipo3 p3):d1(p1),d2(p2),d3(p3)
{}
};
class NLog
{
// Private Constructor:
private NLog() { }
class TestCounter
{
static void Main()
{
// If you uncomment the following statement, it will generate
// an error because the constructor is inaccessible:
// Counter aCounter = new Counter(); // Error
Counter.currentCount = 100;
Counter.IncrementCount();
System.Console.WriteLine("New count: {0}", Counter.currentCount);
}
}
Ejemplo:
class Persona
{
public Persona( ) //Constructor personalizado
{
Nombre = "";
Apellido = "";
Console.WriteLine("Objeto Construido");
}
public string ObtenerNombreCompleto()
{
return ( Nombre+" "+Apellido );
}
public string nombre
{
get{ return Nombre; }
set{ Nombre = value ; }
}
public string apellido
{
get{ return Apellido; }
set{ Apellido = value; }
}
private string Nombre,Apellido;
}
Ejemplo:
class X {
public:
~X(); // destructor de la clase X
};
...
X::~X() { // definición (off-line) del destructor
...
}
#include <stdlib.h>
class X { // clase
public:
...
~X(){}; // destructor de la clase
};
void* operator new(size_t size, void *ptr) {
return ptr;
}
char buffer[sizeof(X)]; // matriz de caracteres, del tamaño de X
#include <iostream>
using namespace std;
class A {
public:
int x;
A(int i = 1) { x = i; } // constructor por defecto
~A() { // destructor
cout << "El destructor ha sido invocado" << endl;
}
};
Salida:
Valor de a.x: 1
El destructor ha sido invocado
# include <iostream.h>
class Caja {
double longitud, anchura, altura;
public:
Caja (double dim1, double dim2, double dim3);
~Caja (void);
double volumen (void);
};
main ()
{
Caja pequeña(5, 4, 10), mediana (10, 6, 20), grande(20, 10, 30);
cout << "El volumen de la caja grande es " << grande.volumen() << '\n';
}
#include <iostream.h>
class Taco {
public:
Taco (int hard) {
hardness = new int;
*hardness = hard;
}
~Taco() {
cout << "Destroying taco with hardness " ;
cout << *hardness <<;\n';
delete hardness;
}
private:
int *hardness; };
main ()
{
Taco hard(10);
Taco *soft = new Taco (0);
delete soft;
};
Ejemplo