Mapa Colaborativo do Sinal 3G no Brasil
Visualizar Sinal 3G em um mapa maior
Um blog sobre computadores, internet e vida digital.
android:layout_width="fill_parent"
android:layout_height="fill_parent">
android:id="@+id/label"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="Digite aqui:"/>
android:id="@+id/entry"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:background="@android:drawable/editbox_background"
android:layout_below="@id/label"/>
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//setContentView(R.layout.main);
setContentView(R.layout.relative); }

Na última sexta-feira(24/06/2011), a Apple presenteou os milhares de desenvolvedores e entusiastas de seus produtos disponibilizando o SDK da nova versão beta do iOS, o sistema operacional utilizado pela empresa nos produtos portáteis iPad, iPhone e iPod Touch.
Entre as novidades da versão 5.0 do sistema operacional já descobertas pelos programadores, estão uma maior interação com o serviço de Cloud Computing (Programação nas Nuvems) iCloud e atualização de sistema através de conecções Wi-Fi e redes 3G. Mais um passo da empresa de Steve Jobbs para deixar seus produtos cada vez mais independentes da conexãos com computadores.
Além do iOS, a Apple também liberou versões beta 2 do software multimídia iTunes 10.5 e do Apple TV Software, o aparelho que permite transformar sua TV em uma central multimídia com total sincronia com os demais produtos da empresa e acesso a uma loja de programas (a exemplo da appStore e da iBooks Store) onde é possível adquirir a mídia e exibi-la diretamente em Alta Defenição na sua TV.
Ficou interessado? Então você já pode acessar o iOS Dev Center e conferir as novidades, logicamente desde que você tenha uma licensa de desenvolvedor.
Mas, se deseja saber mais ainda sobre as inovações do iOS beta 2, o site MacMagazine está fazendo uma cobertura das inovações assim que são descobertas pelos developers de todo mundo ou noticiadas pela própria Apple.



CREATE TABLE casa (
id INTEGER NOT NULL PRIMARY KEY
);
CREATE TABLE morador (
id INTEGER NOT NULL PRIMARY KEY,
casaId INTEGER
CONSTRAINT fk_casa_id REFERENCES casa(id)
);
-- Foreign Key Preventing insert
CREATE TRIGGER fki_morador_casaId_casa_id
BEFORE INSERT ON [morador]
FOR EACH ROW BEGIN
SELECT RAISE(ROLLBACK, 'insert on table "morador" violates foreign key constraint "fki_morador_casaId_casa_id"')
WHERE NEW.casaId IS NOT NULL AND (SELECT id FROM casa WHERE id = NEW.casaId) IS NULL;
END;
-- Foreign key preventing update
CREATE TRIGGER fku_morador_casaId_casa_id
BEFORE UPDATE ON [morador]
FOR EACH ROW BEGIN
SELECT RAISE(ROLLBACK, 'update on table "morador" violates foreign key constraint "fku_morador_casaId_casa_id"')
WHERE NEW.casaId IS NOT NULL AND (SELECT id FROM casa WHERE id = NEW.casaId) IS NULL;
END;
-- Foreign key preventing delete
CREATE TRIGGER fkd_morador_casaId_casa_id
BEFORE DELETE ON casa
FOR EACH ROW BEGIN
SELECT RAISE(ROLLBACK, 'delete on table "casa" violates foreign key constraint "fkd_morador_casaId_casa_id"')
WHERE (SELECT casaId FROM morador WHERE casaId = OLD.id) IS NOT NULL;
END;
Ruby on Rails instalando, é hora de atualizar a sua versão para a mais nova, devemos abrir o console, conforme explicado no parágrafo anterior e digitarmos no prompt:C\:InstantRails> gem update rails --include-dependecies
$sudo aptitude update
$sudo aptitude install build-essential
$sudo aptitude install ruby rubygems ruby1.8-dev libsqlite3-dev
$sudo gem install -y rails
$sudo gem update sqlite3-ruby
Calculator calc = GetCalculator();
int sum = calc.Add(10, 20); object calc = GetCalculator();
Type type = calc.GetType();
object result = type.InvokeMember("Add",
BindingFlags.InvokeMethod, null,
new object[] { 10, 20 });
int sum = Convert.ToInt32(result);
ScriptObect calc = GetCalculator();
object result = calc.InvokeMember("Add", 10, 20);
int sum = Convert.ToInt32(result);dynamic calc = GetCalculator();
int result = calc.Add(10, 20);Mudando de paradigmas
Sem falar das famosas IDEs para o desenvolvimento Java como o NET Beans, distribuído e mantido pela própria Sun e o Eclipse, desenvolvido a princípio pela IBM e que mais tarde tornou-se open source onde apesar de ganhar notoriedade pelas ferramentas e recursos para desenvolvimento em Java, pode ser usada para o desenvolvimento em outras linguagem, desde que extensões compatíveis sejam instaladas. Ambas possuem, entretanto, a característica de serem modulares e adequarem-se as necessidades do usuário.
Se você ficou interessado em iniciar a programar em Linux, não perca o próximo post da série com uma lista de ferramentas disponíveis para o S.O tanto nas etapas de implementação de código, quanto em modelagem de sistemas e distribuição e seus similares no ambiente Windows.
Um recurso muito legal e útil usado em páginas da web 2.0, é o chamado “live search”. O live search consiste em uma caixa de pesquisa cujos resultados são exibidos em tempo real sem precisar recarregar toda a página. O exemplo é bem simples e pode ser visto em http://solleon.hostdegraca.com/cafecombits/livesearch/, onde basta digitarmos três letras e o resultado da pesquisa já é exibido logo a baixo.
Vamos agora demonstrar passo a passo como fazer uma busca do tipo “live search” para suas aplicações online.
Para o exemplo vamos criar um banco de dados em MYSQL bem simples, contendo somente uma tabela, como monstrado a seguir:
O script de criação do BD é:
SET SQL_MODE="NO_AUTO_VALUE_ON_ZERO";
--
-- Banco de Dados: `exemplo`
--
-- --------------------------------------------------------
--
-- Estrutura da tabela `Frases`
--
CREATE TABLE IF NOT EXISTS `Frases` (
`CodFrase` int(11) NOT NULL auto_increment,
`frase` varchar(255) NOT NULL,
`autor` varchar(50) NOT NULL default 'Desconhecido',
PRIMARY KEY (`CodFrase`),
KEY `frase` (`frase`,`autor`),
FULLTEXT KEY `frase_2` (`frase`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 COMMENT='Frases interessantes' AUTO_INCREMENT=49 ;
Se preferir baixar este script, clique aqui.
Para excecutar o script de criação, podemos abrir o prompt de comando e simplesmente digitar:
shell> mysql < arquivo_texto
Também podemos abrir o client mysql e digirtar:
mysql> source filename
O client fará tudo de forma automatizada e teremos nosso banco de dados criado.
Cadastre algumas frases no banco de dados para poder vizualisar o exemplo mais tarde.
Nossa página em HTML será bem simples, terá apenas uma caixa de busca no topo, onde o usuário irá digitar uma palavra, e as frases que a contiverem serão exibidas logo abaixo.
Seu código HTML deve conter um form e uma div que daremos o nome de “resultado” para exibição dos resultados da consulta. O form deve ter um controle input, onde o evento onhotkey deve chamar uma função que fará a consulta.
Código HTML da página “index.html” do exemplo
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<title>Exemplo de Live Search</title>
<style type="text/css">
<!--
body {
font-family: Arial, Helvetica, sans-serif; font-size: 0.7em;
color:#000;
margin:0;
padding:0;
}
#page {
width:720px;
height:100%;
margin-left:auto;
margin-right:auto;
margin-top:0;
padding:0;
}
#content {
width:85%;
margin-left:auto;
margin-right:auto;
padding:0;
padding-top:30px;
padding-left:5px;
padding-right:5px;
text-align:justify;
}
#resultado
{
background: #F5F5F5;
padding:15px;
border:#999 3px dashed;
}
.titulo {
font-size: 1.5em;
font-weight: bold;
text-align:center;
}
.subtitulo {
font-size: 1.3em;
font-weight: bold;
text-align:center;
}
label, input {
display: block;
}
fieldset {
border: dashed 3px #999;
background:#F5F5F5;
padding:15px;
}
-->
</style>
<script src="ajax.js" language="javascript" type="text/javascript"></script>
</head>
<body>
<div id="page">
<div id="content">
<span class="titulo">
Exemplo de Live Search usando AJAX, MYSQL E PHP
<br /><br />
</span>
<!-- este é o form de pesquisa, repare que não tem action e nem um controle submit-->
<form name="busca">
<fieldset>
<legend>Buscar frases</legend>
<!-- esta eh a caisa de pesquisa, repare no onkeyup chamando a funcao Buscar que fara a pesquisa-->
<input type="text" size="89" maxlength="255" name="texto" onkeyup="Buscar();" />
</fieldset>
</form>
<br />
<br />
<!-- essa div conterá o resultado da busca-->
<div id="resultado"><span class='subtitulo'>Digite uma palavra com mais de 2 (duas) letras. Por exemplo, <i>vida</i></span></div>
</div>
</body>
</html>
Este código HTML pode ser baixando na íntegra clicando aqui.
Salve o arquivo como “index.html” no seu servidor WEB.
O javascript da página, conterá funções que interpretam e tratam a entrada do usuário, que criam o xml request e lê o xml com o resultado da busca gerado dinamicamente e, por fim, formataram o resultado para o html adicionando a página.
Por razões óbvias, chamaremos esse arquivo de javascript de “ajax.js”, segue o código fonte do mesmo:
// JavaScript Document
var http_request = false;
//funcao que realiza a busca
function Buscar()
{
//pegando o valor do controle no form na pagina
var text = document.busca.texto.value;
//se o comprimento do texto for maior que dois
if (text.length >2)
{
//definindo pagina que fara a consulta e retornará o xml
var url = "buscar.php";
url += "?q="+text;
//gerando uma imagem do tipo carregando para que o usuario saiba que esta sendo feita uma busca no banco de dados
document.getElementById("resultado").innerHTML = "<div align='center' class='subtitulo'><img src='ajax-loader.gif' alt='Carregando...' /><br /><br />Carregando...</div>";
//chamando funcao que verifica se a busca pode ser feita
AtualizaResultado(url);
}
else
{
document.getElementById("resultado").innerHTML = "<span class='subtitulo'>Digite uma palavra com mais de 2 (duas) letras. Por exemplo, <i>vida</i></span>";
}
}
//coracao do ajax, cria o objeto xmlhttprequest e tenta lelo
function AtualizaResultado(url)
{
http_request = false;
if (window.XMLHttpRequest) { // Mozilla, Safari,...
http_request = new XMLHttpRequest();
if (http_request.overrideMimeType) {
http_request.overrideMimeType('text/xml');
}
} else if (window.ActiveXObject) { // IE
try {
http_request = new ActiveXObject("Msxml2.XMLHTTP");
} catch (e) {
try {
http_request = new ActiveXObject("Microsoft.XMLHTTP");
} catch (e) {}
}
}
if (!http_request) {
alert('Não foi possível criar uma instância XMLHTTP');
return false;
}
http_request.onreadystatechange = mudancaDeEstado; // essa funcao eh chamada quando o xml eh carregado
http_request.open('GET', url, true);
http_request.send(null);
}
//funcao que controi o resultado da busca
function mudancaDeEstado()
{
var retorno = "";
//definindo o xml
var xmldoc = http_request.responseXML;
//navegando para a tag item
var lst = xmldoc.getElementsByTagName('item');
var total = 0;
//criando a tabela para exibicao dos dados
retorno = "<table width='100%' border='0' cellpadding='2' cellspacing='2'>";
//percorrendo todos os itens
for (var i=0;i<lst.length;i++)
{
var frase = "";
var autor = "";
total = total +1;
var objNode = lst[i];
if (objNode.nodeType == 1)
{
for (var j=0;j<objNode.childNodes.length;j++)
{
var objNI = objNode.childNodes[j];
if (objNI.nodeType == 1)
{
switch (objNI.nodeName)
{
case "frase":
frase = objNI.firstChild.nodeValue;
break;
case "autor":
autor = objNI.firstChild.nodeValue;
break;
}
}
}
}
//criando row na tabela que conterá a frase e o autor
retorno += "<tr><td><i>""+frase+""</i> <strong>"+autor+"</strong></td></tr>";
}
if (total > 0)
{
retorno += "<tr><td><strong>"+total+" frase(s) listada(s)</strong></td></tr></table>";
}
else // no caso de não ter encontrado nenuma frase
{
retorno = "<span class='subtitulo'>Nenhuma frase encontrada com esta palavra</span>"
}
//escrevendo o resultado no documento
document.getElementById("resultado").innerHTML = retorno;
}
Para baixar o arquivo já pronto, clique aqui.
Você deve salvar este arquivo como “ajax.js” no mesmo diretório onde salvou o “index.html”, no seu servidor WEB.
Agora iremos confeccionar a página PHP que fará a consulta no banco de dados e formatará o resultado em um arquivo xml para ser usado pelo javascript. O nome do arquivo do exemplo será “search.php”.
Código fonte, lembre-se de alterar os dados da conexão ao banco de dados:
<?php
//capturando variaveis
$buscar = $_GET["q"];
//abrindo conexao com o bancode dados
$link = mysql_connect("hostmysqlqualquer", "usuario", "senha");
if (!$link)
{
echo 'Não foi possível selecionar o banco de dados';
die('Não foi possível conectar: ' . mysql_error());
}
if (!mysql_select_db('exemplo', $link))
{
echo 'Não foi possível selecionar o banco de dados';
exit;
}
//criando a consulta
$sql = "SELECT * FROM Frases";
if (isset($buscar) && $buscar != '')
{
$sql .= " WHERE frase LIKE '%".$buscar."%'";
$sql .= " ORDER BY frase";
}
//executando a consulta
$result = mysql_query($sql, $link);
if (!$result)
{
echo "Erro do banco de dados, não foi possível consultar o banco de dados\n";
echo 'Erro MySQL: ' . mysql_error();
exit;
}
//montando o xml de saida
echo '<?xml version="1.0" encoding="iso-8859-1"?>'."\n";
echo "<frases>\n";
while ($row = mysql_fetch_assoc($result))
{
echo "\t<item>\n";
echo "\t\t".'<frase>'.$row['frase'].'</frase>'."\n";
echo "\t\t".'<autor>'.$row['autor'].'</autor>'."\n";
echo "\t</item>\n";
}
mysql_close($link);
echo '</frases>';
?>
Se preferir baixá-lo, clique aqui.
Salve no mesmo diretório onde estão os outros arquivos, com o nome de “search.php”, no seu servidor WEB, coloque também a figura que será exibida quando a consulta estiver sendo executada no mesmo diretório, para baixá-la clique aqui.
Pronto! Agora é só acessar “index.html” do seu browser e testar se o exemplo está funcionando bem no seu servidor WEB. Não se esqueça de inserir alguns registros no banco de dados para poder testar a pesquisa! Valeu e até a próxima pessoal!
Por Solleon Menezes
Se você ainda não sabe o que é RSS, dê uma lida no post RSS e asp.net parte I , que você encontrará os conceitos introdutórios sobre o tema.
Para que qualquer site possa servir RSS, é necessário que ele forneça ao programa leitor, um arquivo XML, contendo os dados, pois RSS, como já sabemos, é nada mais que um arquivo XML que segue uma padronização da estrutura específica. Podemos fornecer esse XML de duas formas, ou através de um arquivo estático XML propriamente dito salvo em nosso servidor, ou por meio de uma página PHP que pode gerar esse XML dinamicamente para nós. No nosso caso vamos gerar por meio de uma página PHP.
Antes de partirmos para a feitura da página, precisamos antes guardar as informações que publicaremos no RSS em algum lugar. Na informática, lugar de armazenar informações é em banco de dados. No nosso caso usaremos o banco open-source MySQL, disponível para download em http://www.mysql.com.
A estrutura do arquivo RSS é bem definida. Temos as seguintes entidades Channel e Item, que possuem a seguinte estrutura e se relacionam da seguinte forma:
O script para criação dessa estrutura é este:
SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0;
SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0;
SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='TRADITIONAL';
CREATE SCHEMA IF NOT EXISTS `RSS` ;
USE `RSS`;
-- -----------------------------------------------------
-- Table `RSS`.`Channel`
-- -----------------------------------------------------
CREATE TABLE IF NOT EXISTS `RSS`.`Channel` (
`idChannel` INT NOT NULL AUTO_INCREMENT ,
`title` VARCHAR(255) NULL DEFAULT NULL ,
`link` VARCHAR(255) NULL DEFAULT NULL ,
`description` TEXT NULL DEFAULT NULL ,
PRIMARY KEY (`idChannel`) )
ENGINE = InnoDB;
-- -----------------------------------------------------
-- Table `RSS`.`Item`
-- -----------------------------------------------------
CREATE TABLE IF NOT EXISTS `RSS`.`Item` (
`idItem` INT NOT NULL AUTO_INCREMENT ,
`title` VARCHAR(255) NULL DEFAULT NULL ,
`link` VARCHAR(255) NULL DEFAULT NULL ,
`description` TEXT NULL DEFAULT NULL ,
`idChannel` INT NULL DEFAULT NULL ,
PRIMARY KEY (`idItem`) ,
CONSTRAINT `fk_Item_Channel`
FOREIGN KEY (`idChannel` )
REFERENCES `RSS`.`Channel` (`idChannel` )
ON DELETE RESTRICT
ON UPDATE CASCADE)
ENGINE = InnoDB;
CREATE INDEX fk_Item_Channel ON `RSS`.`Item` (`idChannel` ASC) ;
SET SQL_MODE=@OLD_SQL_MODE;
SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS;
SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS;
Você também pode baixá-lo na integra aqui.
Para excecutar o script de criação, podemos abrir o prompt de comando e simplesmente digitarmos:
shell> mysql < arquivo_textomysql> source filename<?php
//criando cabeçalho do arquivo
$xml = '<?xml version="1.0" encoding="iso-8859-1"?>'."\n";
$xml .= '<rss version="2.0">'."\n";
//setando dados da conexao e do banco voce deve substituir pelos seus dados de conexão
$host = "mysql.test.com";
$user = "usuario";
$pass = "senha";
$db = "RSS";
//fazendo a conexão com o banco de dados que contem os dados RSS
mysql_connect($host, $user, $pass);
mysql_select_db($db);
//pegando dados do channel no banco
$sql = "SELECT idChannel, title, description, link FROM Channel ORDER BY idChannel DESC";
$reschan = mysql_query($sql);
//enquanto ainda houver dados do channelm executar codigo dentro do while
while ($rowchan = mysql_fetch_assoc($reschan))
{
//abrindo tag do Channel
// obs: \n = nova linha
$xml .= '<channel>'."\n";
//formatando os dados nas tags rss do Channel
$xml .= '<title>'.htmlspecialchars($rowchan['title']).'</title>'."\n";
$xml .= '<description>'.htmlspecialchars($rowchan['description']).'</description>'."\n";
$xml .= '<link>'.htmlspecialchars($rowchan['link']).'</link>'."\n";
//pegando dados dos Itens do Channel no banco de dados
$sql = "SELECT title, link, description FROM Item WHERE idChannel = ".$rowchan['idChannel']." ORDER BY idItem DESC";
$result = mysql_query($sql);
//enquanto ainda houver itens no banco, executar codigo dentro do while
while ($row = mysql_fetch_assoc($result))
{
//formatando dados do item nas tags RSS
$xml .= '<item>'."\n";
$xml .= '<title>'.htmlspecialchars($row['title']).'</title>'."\n";
$xml .= '<description>'.htmlspecialchars($row['description']).'</description>'."\n";
$xml .= '<link>'.htmlspecialchars($row['link']).'</link>'."\n";
$xml .= '</item>'."\n";
}
//fechando tag do channel
$xml .= '</channel>'."\n";
}
//fechando a tag rss
$xml .= '</rss>';
//retornando todo o xml pro leitor de rss do usuário
echo $xml;
?>O código fonte acima pode ser baixado aqui. Salve a página PHP em seu servidor PHP e pronto! Bastará colocar o endereço da página no seu leitor de RSS e você verá que funciona!O objetivo deste artigo é ser uma introdução à Programação Orientada a Objetos (POO) primeiro a partir de um escopo global, depois sob a ótica do C#.
Se você já é programador, mas não conhecia ou utilizava POO em suas soluções, provavelmente sentirá uma enorme dificuldade em se adequar à POO, pois adotar POO é enxergar a programação sob um aspecto completamente diferente do usual. Apesar de difícil no início, POO traz enormes vantagens em termos de reusabilidade de código (você digitará menos e de forma mais eficiente =] ), melhoria na lógica da aplicação (ficará mais fácil “ver” como seu sistema funciona), manutenção (alterações nos programas serão menos traumáticas), colaboração (ficará mais fácil dividir o trabalho em equipe), etc. Você talvez esteja se perguntando; “Se POO integra todos esses benefícios, por que não é unanimidade entre os desenvolvedores?” Como dito no início, aprender POO não é fácil, mas o pior mesmo é alterar velhos hábitos cultuados por 50 anos de desenvolvimento de software baseado em programação estruturada.
CLASSES E OBJETOS
As linguagens orientadas a objeto, tem como idéia primordial tornar a estrutura e a lógica do programa um pouco mais próximos do mundo “real”. Basicamente temos em uma mesma unidade lógica funcional, que armazena em sua estrutura dados (equivalentes às variáveis) e meios de manipulá-los (equivalentes a procedimentos e funções). Estes dados são chamados de “campos de dados” e os meios de manipulação “campos de funções”. Tal unidade lógica é chamada de CLASSE. Recomendo que fixe bem este parágrafo antes de passar aos demais.
Uma classe é considerada um tipo de dado, como os tipos básicos pré-definidos (inteiro, real, string, etc.) em todas as linguagens de programação. O que quero dizer é que da mesma forma que podemos criar uma variável do tipo “boolean” também podemos criar uma variável do tipo da classe. Esta variável da classe é chamada de OBJETO.
Ao definirmos uma classe, estamos fornecendo o esqueleto para o objeto. Toda vez que declaramos uma variável originada de uma classe dizemos que ‘instanciamos um objeto”. Os campos de dados de uma classe após serem instanciados são chamados de “variáveis de instância” e os campos de funções de “métodos” ou “funções membros”. Então POO é isso? Definir tipos novos e usá-los? Na verdade a coisa é bem mais profunda. Quando definimos uma classe estamos criando um modelo – um molde – para criarmos objetos e/ou outras classes. Para que a POO esteja bem implementada os campos de dados não devem ser vistos e alterados de fora da classe diretamente. Quem deve manipular estes dados e “enxergá-los” são os campos de funções. Assim qundo este princípio da POO é seguido em uma classe, dizemos que os campos de dados estão “escondidos” ou seja, NÃO DEVEM SER ACESSADOS DIRETAMENTE DE FORA DE UMA CLASSE! Ok, mas porque devemos ter todo esse cuidado com os estes dados? Tal precaução existe para evitarmos alterações acidentais em dados que possam comprometer o bom funcionamento do programa. Assim ao declararmos um campo dentro de uma classe estamos escondendo-o do resto da aplicação. Também existe para evitarmos conflitos de nomes de variáveis, pois ambas não se enxergam. Isolar campos de dados e fazê-los ser acessíveis somente por campos de funções é uma técnica conhecida como encapsulamento. Encapsular sigifica esconder toda a complexidade do tratamento dos campos de dados, rotinas, etc. de fora de uma classe. Podemos “encapsular” tanto campos de dados quanto campos de funções. Quando os campos de dados estão encapsulados e escondidos fica fácil saber quando, como e onde um campo é acessado e alterado pois somente determinados campos de funções (métodos) podem acessá-los. Dentro dessa perspectiva existem campos de funções especiais, conhecidos como PROPRIEDADES. As propriedades de fora de uma classe são vistas como campos “descobertos”, mas de dentro da classe, são funções membros que permitem um meio seguro de acessar os campos de dados. As propriedades podem acessar campos de dados diretamente ou mesmo retornar valores calculados como se fossem campos de dados. Quando uma propriedade somente tem valor de retorno a mesma é dita como somente leitura. Quando chamamos uma função membro de um objeto, dizemos que estamos trocando mensagens com o objeto. De fato um programa em POO consiste em diversos objetos trocando mensagens entre si.
HERANÇA
Além de tudo POO possibilita a herança. Herança é uma forma de relacionarmos classes passando seus campos para outras de maneira hierárquica. Dessa forma se temos uma classe chamada “seres” com a característica “existir” ao relacionarmos esta como ponto chave da hierarquia com as classes “seres vivos”, “seres inanimados”, ambas herdaram da classe “seres” a característica “existir”. A classe que cede as características as demais é conhecida como “classe base” ou pai, e as que herdam “derivadas” ou filhas. A implementação de classes devem obedecer as características comuns a todo o sistema e então ir afunilando em características individuas de cada unidade do mesmo. Esta forma de progamação simplifica enormemente a manutenção do sistema, pois ao alterarmas uma característica em uma classe pai, automaticamente todas as filhas herdaram esta mudança. Ganhamos então um código altamente estruturado. Esta característica da POO é sem sombra de dúvidas um aliado fortíssimo das aplicações robustas e bem gerenciadas.
POFIMORFISMO E SOBRECARGA