wpjr2’s Weblog

Artigos e tutoriais úteis

Archive for 23 de abril de 2008

SCJP 6.0 vs. 5.0 vs. 1.4: Diferenças

Posted by wpjr2 em abril 23, 2008

How is the SCJP 1.6 exam different from the SCJP 1.5?

  • Exam objectives: Several new API classes/interfaces have been added: java.io.Console, java.util.NavigableSet, java.util.NavigableMap. Explicit garbage collector calls (i.e. System.gc()) will no longer be tested, but candidates will still be expected to understand garbage collection and the finalize() method. Also, the following topics will be tested in greater depth: exception handling, collections, assertions, threads, and flow control. See the SCJP forum for more details.
  • Number of questions: 72 (no change)
  • Time: 210 minutes (increased from 175 minutes)
  • Passing score: 65% (increased from 59%)
  • Format of questions: No change.

How is the SCJP 1.5 exam different from the SCJP 1.4?

  • Exam objectives: Several important new language features have been added, including enums, generics, static imports, and autoboxing/unboxing. API features added to the exam include java.lang.StringBuilder, java.util.Locale, java.util.Formater, java.util.Scanner. java.util.regex.Pattern, and java.util.regex.Matcher. Java IO features have been added, including File, BufferedReader, BufferedWriter, FileReader, FileWriter and PrintWriter. Concepts such as loose coupling and high cohesion have been added, as well as greater emphasis on encapsulation as it relates to JavaBean conventions. Bit manipulation (e.g., shifting) has been dropped.
  • Number of questions: 72 (increased from 61)
  • Time: 175 minutes (increased from 120 minutes)
  • Passing score: 59% (increased from 52%)
  • Level of difficulty: The concensus is that it is more difficult.
  • Format of questions: As before, you will always be told how many options to choose. No credit is given for partial answers. Drag-and-drop questions were also introduced for this version of the exam.
Anúncios

Posted in Certificações, Curso de Programação Java | Etiquetado: , | 1 Comment »

Comparando C e Java

Posted by wpjr2 em abril 23, 2008

Feature C Java
type of language function oriented object oriented
basic programming unit function class = ADT
portability of source code possible with discipline yes
portability of compiled code no, recompile for each architecture yes, bytecode is “write once, run anywhere”
security limited built-in to language
compilation gcc hello.c creates machine language code javac Hello.java creates Java virtual machine language bytecode
linking in the Math library gcc -lm calculate.c no special flags needed
joint compilation gcc main.c helper1.c helper2.c javac Main.java – any dependent files are automatically re-compiled if needed
execution a.out loads and executes program java Hello interprets byte code
hello, world #include<stdio.h>
int main(void) {
printf("Hello\n");
return 0;
}
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello");
}
}
integer types int usually 32 bit 2’s complement;
long usually 32 bit 2’s complement
int is 32 bit 2’s complement;
long is 64 bit 2’s complement
floating point types float usually 32 bit;
double usually 64 bit
float is 32 bit IEEE 754 binary floating point;
double is 64 bit IEEE 754
boolean type use int: 0 for false, nonzero for true boolean is its own type – stores value true or false
character type char is usually 8 bit ASCII char is 16 bit UNICODE
for loops for (i = 0; i < N; i++) for (int i = 0; i < N; i++)
array declarations int *a = malloc(N * sizeof(*a)); int[] a = new int[N];
array size arrays don’t know their own size a.length
strings ''-terminated character array built-in immutable String data type
accessing a library #include <stdio.h> import java.io.File;
accessing a library function #include "math.h"
x = sqrt(2.2);

all function and variables names are global
x = Math.sqrt(2.2);
functions have different namespaces
printing to standard output printf("sum = %d", x); System.out.println("sum = " + x);
formatted printing printf("avg = %3.2f", avg); System.out.printf("avg = %3.2f", avg)
reading from stdin scanf("%d", &x); Java library support, but easier to use our library
int x = StdIn.readInt();
memory address pointer reference
manipulating pointers *, &, + no direct manipulation permitted
functions int max(int a, int b) public static int max(int a, int b)
pass-by-value primitive data types, structs, and pointers are passed by value; array decays to pointer all primitive data types and references (which includes arrays), are passed by value
defining a data structure struct class – key difference is language support for defining methods to manipulate data
accessing a data structure a.numerator for elements a.numerator for instance variables,
c = a.plus(b) for methods
pointer chasing x->left->right x.left.right
allocating memory malloc new
de-allocating memory free automatic garbage collection
memory allocation of data structures and arrays heap, stack, data, or bss heap
buffer overflow segmentation fault, core dump, unpredicatable program checked run-time error exception
declaring constants const and #define final
variable auto-initialization not guaranteed instance variables (and array elements) initialized to 0, null, or false, compile-time error to access uninitialized variables
data hiding opaque pointers and static private
interface method non-static function public method
data type for generic item void * Object
casting anything goes checked exception at run-time or compile-time
demotions automatic, but might lose precision must explicitly cast, e.g., to convert from long to int
polymorphism union inheritence
overloading no yes for methods, no for operators
graphics use external libraries Java library support, use our standard drawing library
null NULL null
enumeration enum typesafe enum
preprocessor yes no
variable declaration at beginning of a block before you use it
variable naming conventions sum_of_squares sumOfSquares
commenting /* */ /* */ or //
file naming conventions stack.c, stack.h Stack.java – file name matches name of class
callbacks pointers to global functions use interfaces for commmand dispatching
variable number of arguments varargs String ...
assertions assert assert
exit and return value to OS exit(1) System.exit(1)

Posted in Curso de Programação Java | Etiquetado: , | Leave a Comment »

Gerenciando bibliotecas de projetos no Eclipse

Posted by wpjr2 em abril 23, 2008

É comum a necessidade de atualizar bibliotecas em que um dado projeto Java depende ou utiliza. Para isto, os seguintes passos são necessários:

  1. Selecionar o projeto no PACKAGE EXPLORER, clicar com o botão direito sobre o nome do projeto, selecionar PROPERTIES, opção JAVABUILD PATH, aba LIBRARIES
  2. Remover a(s) biblioteca(s) antiga(s)
  3. Selecionar via “Add External Jar” para arquivos JAR externos ao projeto ou “Add Jar” para arquivos JAR internos no projeto (pasta lib).
  4. Após a atualização, clicar em OK. O Eclipse irá automaticamente compilar o projeto considerando as novas bibiotecas.

Dicas:

  • É comum que as bibiotecas em que o projeto depende serem inseridas dentro de um diretório no projeto, por exemplo de nome LIB. Sempre que atualizações precisarem ser feitas, as libs antigas podem ser substituidas pelas novas dentro deste diretório mesmo.
  • Para bibiotecas mais comuns (JUnit, Servlets, JDBC, etc)., é normal criar uma variável de ambiente do Eclipse, onde via esta todos os projetos podem utilizar o mesmo JAR, possibilitando a reusabilidade. Isto é possível via “Add Variable” na aba “Libraries” no Java Build Path das propriedades do projeto.

Posted in Curso de Programação Java, Eclipse | Etiquetado: , , , | Leave a Comment »

Orientação por Objetos: Vantagens e Desvantagens

Posted by wpjr2 em abril 23, 2008

História

Nos anos 60 é lançado a Simula-67 que apresentou pela primeira vez os conceitos de classes, rotinas correlatas e subclasses. Na década de 70 a Seros-PARC cria a Smalltak até hoje considerada a mais pura das LPOO. No final da década de 80 aparece a C++, uma linguagem híbrida.
Orientação a Objetos é o maior avanço em software destes últimos anos. É uma forma mais natural de se analisar o mundo. Ela nos permite construir sistemas melhores e, além disso, de maneira mais fácil. Será a mais importante das tecnologias emergentes na área de software nos anos 90.
As técnicas estruturadas que, sem dúvida, atualmente são as mais populares na comunidade de informática, obtiveram grande aceitação desde que foram lançadas no final dos anos 70. Contudo a medida que foram sendo utilizadas, a decomposição funcional mostrou-se inadequada em situações de sistemas complexos e principalmente para profissionais iniciantes. Os aperfeiçoamentos introduzidos em 1984, por Sthephen M e John F Palmer e, mais tarde, complementados por Stephen Mellor e Paul Ward, para sistemas em real-time, ajudaram a análise estruturada a se tornar mais eficiente. Contudo os sistemas criados com as técnicas estruturadas ainda são difíceis de serem incrementados com novas funções e as alterações em funções já existentes, muitas vezes, provocam sérios problemas em outras partes do software.

A Reutilização
A reutilização está baseada na padronização a qual é adotada há longa data em toda a indústria moderna, seja no projeto de carros, televisores, computadores, etc. A padronização traz inúmeras vantagens, entre elas podemos citar a seguintes:

  1. as peças padrões são mais baratas
  2. são mais confiáveis
  3. geralmente são mais fáceis de serem consertadas ou substituídas

Na informática a reutilização de códigos ainda é praticada em escala muito reduzida e decorrente da iniciativa isolada de alguns programadores e projetistas. São vários os motivos para isso, entre eles:

  1. existência de uma Biblioteca e de um Sistema de Catálogo
  2. facilidade para documentação
  3. sistemática rigorosa para testes
  4. novas técnicas para especificação de sistemas tendo em vista a reutilização de módulos
  5. linguagem, ferramentas e ambientes de desenvolvimento que estimulem a adoção, em larga escala, de tais métodos dentro das empresas
  6. criação de novos geradores de sistemas que operem selecionando e combinando módulos padrões e que satisfaçam as necessidades específicas das aplicações
  7. mudança administrativas e gerenciais nas empresas de modo a apoiarem e estimularem os criadores de módulos padrões.

Vantagens da Orientação a Objetos

  • Vantagens Diretas – maior facilidade para reutilização de código e por conseqüência do projeto – possibilidade do desenvolvedor trabalhar em um nível mais elevado de abstração – utilização de um único padrão conceitual durante todo o processo de criação de software – maior adequação à arquitetura cliente/servidor – maior facilidade de comunicação com os usuários e com outros profissionais de informática.
  • Vantagens Reais – ciclo de vida mais longo para os sistemas – desenvolvimento acelerado de sistemas – possibilidade de se construir sistema muito mais complexos, pela incorporação de funções prontas – menor custo para desenvolvimento e manutenção de sistemas

Desvantagens

  • Complexidade no aprendizado para desenvolvedores de linguagens estruturadas
  • Maior uso de memória (heap), por exemplo para aplicações móveis em JavaME
  • Maior esforço na modelagem de um sistema OO do que estruturado (porém menor esforço de codificação, sendo uma vantagen)
  • Funcionalidades limitadas por interface, quando estas estão incompletas (problemas na modelagem)
  • Dependência de funcionalidades já implementadas em superclasses no caso da herança, implementações espalhadas em classes diferentes

Posted in Curso de Programação Java | Etiquetado: , | 2 Comments »

Modificadores de Acesso (Tutorial Java Oficial)

Posted by wpjr2 em abril 23, 2008

Controlling Access to Members of a Class

Access level modifiers determine whether other classes can use a particular field or invoke a particular method. There are two levels of access control:

  • At the top level—public, or package-private (no explicit modifier).
  • At the member level—public, private, protected, or package-private (no explicit modifier).

A class may be declared with the modifier public, in which case that class is visible to all classes everywhere. If a class has no modifier (the default, also known as package-private), it is visible only within its own package (packages are named groups of related classes—you will learn about them in a later lesson.)

At the member level, you can also use the public modifier or no modifier (package-private) just as with top-level classes, and with the same meaning. For members, there are two additional access modifiers: private and protected. The private modifier specifies that the member can only be accessed in its own class. The protected modifier specifies that the member can only be accessed within its own package (as with package-private) and, in addition, by a subclass of its class in another package.

The following table shows the access to members permitted by each modifier.

Access Levels
Modifier Class Package Subclass World
public Y Y Y Y
protected Y Y Y N
no modifier Y Y N N
private Y N N N

The first data column indicates whether the class itself has access to the member defined by the access level. As you can see, a class always has access to its own members. The second column indicates whether classes in the same package as the class (regardless of their parentage) have access to the member. The third column indicates whether subclasses of the class — declared outside this package — have access to the member. The fourth column indicates whether all classes have access to the member.

Access levels affect you in two ways. First, when you use classes that come from another source, such as the classes in the Java platform, access levels determine which members of those classes your own classes can use. Second, when you write a class, you need to decide what access level every member variable and every method in your class should have.

Let’s look at a collection of classes and see how access levels affect visibility. The following figure shows the four classes in this example and how they are related.

Classes and Packages of the Example Used to Illustrate Access Levels

Classes and Packages of the Example Used to Illustrate Access Levels

The following table shows where the members of the Alpha class are visible for each of the access modifiers that can be applied to them.

Visibility
Modifier Alpha Beta Alphasub Gamma
public Y Y Y Y
protected Y Y Y N
no modifier Y Y N N
private Y N N N

Tips on Choosing an Access Level: If other programmers use your class, you want to ensure that errors from misuse cannot happen. Access levels can help you do this.

  • Use the most restrictive access level that makes sense for a particular member. Use private unless you have a good reason not to.
  • Avoid public fields except for constants. (Many of the examples in the tutorial use public fields. This may help to illustrate some points concisely, but is not recommended for production code.) Public fields tend to link you to a particular implementation and limit your flexibility in changing your code.

Posted in Curso de Programação Java | Etiquetado: | Leave a Comment »

Lista completa dos modificadores de acesso

Posted by wpjr2 em abril 23, 2008

Modificadores

Em Java existem uma série de palavras-chave que se comportam como modificadores de classes, métodos e atributos. Alguns desses modificadores já foram usados nesta apostila como a palavra-chave public, por exemplo. Um modificador pode ser utilizado antes da palavra class, antes do retorno de um método ou antes da declaração de um atributo.

Abaixo segue uma tabela com todos os modificadores de acesso do Java. A ordem de declaração dos modificadores não importa.

Palavra-chave Em uma classe Em um m étodo Em um atributo




public Acesso total Acesso total Acesso total.




private Não aplicável Acesso pela classe Acesso pela classe




protected Não aplicável Acesso pelo pacote Acesso pelo pacote




default Somente pacote Acesso pelo pacote Acesso pelo pacote




abstract Não instância Deve ser sobrescrito Não aplicável.




final Sem herança Não pode ser sobrescrito CONSTANTE..




static Não aplicável Acesso pela classe Acesso pela classe




native Não aplicável Indica código nativo Não aplicável




transient Não aplicável Não aplicável Cache




synchonized Não aplicável Sem acesso simultâneo. Não aplicável




Posted in Curso de Programação Java | Etiquetado: | Leave a Comment »