O que é uma classe abstrata
Em uma "categoria", se não houver um método abstrato, então essa classe é chamado de uma classe abstrata, e precisa antes classe abstrata.
Abstract métodos: um método de se nenhum método destes, o método chamado método resumo, porque em multi-estado, o processo é muitas vezes corpo pai redundante, o método de selecção de formar um método abstrato descartado. Sua forma de código:
public abstract class Mammal {//父类
public abstract void move();
}
classe abstrata detalhado
1, se o método abstrato classe pai, você deve subclasse métodos tão abstrato, caso contrário, a subclasse deve ser de classe abstrata, classe abstrata e não pode criar o objeto.
public abstract class Mammal {//父类
public abstract void move();
public abstract void breathe();
}
Subclasse pode ser escrita como:
public class Whale extends Mammal{//子类
@Override
public void move() {
System.out.println("靠鱼鳍游泳");
}
@Override
public void breathe() {
System.out.println("靠鱼鳃游泳");
}
}
ou:
public abstract class Whale extends Mammal{//子类
}
2, classe abstrata não pode criar um objeto, mas pode ter construtor.
public abstract class Mammal {//父类
public Mammal(int age) {//可以创建Mammal方法
//Mammal mammal = new Mammal();mammal不能创建对象
}
public abstract void move();
public abstract void breathe();
}
3, uma classe abstracta não é um método pode resumo, mas método resumo mosto é uma classe abstracta
4, a classe abstracta não (polimorfismo reflectida directamente) pela modificação final.
5, a diferença entre a classe classe abstracta normais:
. Uma classe não pode criar classe abstracta objecto pode ser comum;
B têm a classe abstracta palavra-chave modificação resumo, não existe uma categoria geral ;.
C classe resumo pode ter métodos sumário, a categoria geral. métodos, sem dúvida nenhuma abstratas.
O que é a interface
Se todos os métodos em um arquivo de origem, o método abstrato inteiro, então este pode ser definido para o arquivo de origem interface. forma de código da seguinte forma:
public interface IMammal {
public abstract void move();
public abstract void breathe();
}
interface de detalhe
1, não há qualquer construtor de interface.
2, interface método padrão é abstrato público, ele pode ser ignorado.
public interface IMammal {
/*public IMammal() {//不能构造方法
}*/
void move();//忽略public abstract
void breathe();//忽略public abstract
}
3, uma interface pode herdar várias interfaces.
interface IA{//接口A
}
interface IB{//接口B
}
public interface Mammal extends IA,IB{//继承接口A,B
void move();
void breathe();
}
4, estados: nome da interface começa com I (especificações do código)
5, as variáveis de interface padrão para public static final (ou seja, são constantes estáticas). Então variáveis nomeadas na interface deve ser todos os tampões.
public interface IMammal{
void move();
void breathe();
int AGE = 957;
}
public class Test {
public static void main(String[] args) {
//IMmammal.AGE = 125; //不可实现，代码报错，从而证明5。
System.out.println(IMammal.AGE);
}
}
6, a interface herdada métodos abstratos, requerem o uso de implementos.
7, ao implementar interface, você pode herdar as constantes definidas na interface.
public interface IMammal{
void move();
void breathe();
int AGE = 957;
}
public class Whale implements IMammal{
@Override
public void move() {
}
@Override
public void breathe() {
}
}
public class Test {
public static void main(String[] args) {
System.out.println(IMammal.AGE);
System.out.println(Whale.AGE);
}
}
8, uma classe se todos os métodos abstratos não implementar a interface, em seguida, a classe deve ser abstrato.
public interface IMammal{
void move();
void breathe();
int AGE = 957;
}
public abstract class IWhale implements IMammal{
@Override
public void move() {
}
}
9, uma classe pode implementar várias interfaces.
public abstract class IWhale implements IMammal，List{
@Override
public void move() {
}
@Override
public void breathe() {
}
@Override
public int size() {
// TODO Auto-generated method stub
return 0;
}
@Override
public boolean isEmpty() {
// TODO Auto-generated method stub
return false;
}
}
10, instanceof para determinar se o objecto apontado para a frente do último tipo, o resultado é um tipo booleano.
public class Test {
public static void main(String[] args) {
Whale whale = new Whale();
System.out.println(whale instanceof Whale);
System.out.println(whale instanceof Object);//Object为所有类的父类
System.out.println(whale instanceof IMmammal);
}
}
O resultado é:
a verdade
como verdadeira
a verdade
diferença
1, eo construtor do objeto:
classe abstrata não pode criar um objeto, mas pode ter construtor;
a interface interface não pode usar diretamente a nova palavra-chave para criar um objeto, mas não é limitado e não pode criar um objeto, o método não pode ser abstrato.
2, o modificador:
necessidade classe abstrata para adicionar abstrato antes da aula;
as interfaces precisa adicionar interface de antes do nome da interface, e nenhuma classe.
