1.抽象类: 不能手动创建对象(JVM可以创建抽象类的对象),但是可以声明抽象类型的引用。
public class TestAbstract1{
public static void main(String[] args){
//Animal a=new Animal(); //error
Animal a=null;
a=new Dog();
}
}
abstract class Animal{
}
class Dog extends Animal{
}
2.抽象方法:有方法名的定义,没有实现,(只定义了能做什么,没定义怎么做)
抽象方法的好处是允许方法的定义和实现分开。
abstract class Animal{
public abstract void eat();
}
抽象类和抽象方法的关系:含有抽象方法的类一定是抽象类,抽象类里不一定含有抽象方法
抽象类存在的意义是用来被继承的。一个类继承了一个抽象类,必须实现抽象类里面所有的抽象方法,否则,此类也是抽象类。
abstract class Animal{
public void run(){}
public abstract void sleep();
public abstract void eat();
}
class Dog extends Animal{
public void sleep(){
System.out.println("Dog sleep.");
}
public void eat(){
System.out.println("Dog eat.");
}
}
abstract class Cat extends Animal{
public void eat(){
System.out.println("Cat eat.");
}
}
可以声明父类类型子类对象,利用多态调用抽象方法
public class TestAbstract1{
public static void main(String[] args){
Animal a=null;
a=new Dog();
a.sleep();
a.eat();
}
}
抽象类有构造方法,有父类的,也遵循单继承的规律
class E{}
abstract class Animal extends E{
public Animal(){
super();
}
}
3.多种修饰符的连用问题:
public protected default private static final abstract
可以连用:
public static
private static
public final
public static final
不可以连用:abstract final void eat();
private abstract void eat();
static abstract void eat();
abstract不能和final,private,static连用
/*abstract定义类时方法必须完整的,为什么写不完整的方法,在程序实现过程中有时只要定义规范
不要求实现,写残缺的不完整的方法,你将一个方法定义为残缺的,说明这个类也是残缺的,类前也
要加abstract*/
abstract class Person
{
//public void run(); //方法是不完整的,
public abstract void run();
//抽象类中的实例方法必须实现,抽象方法不能进行实现。
public void add(int a,int b){
System.out.println("woshi");
};
}
//抽象类(abstract)只能拿来继承而不能进行实例化
class Student extends Person//子类必须覆盖父类的抽象方法
{
public void run(){
};
public void add(int a,int b,int c){
System.out.println("aaaaaaaaaaaaaa");
};
}
/*Student 不是抽象的,并且未覆盖 Person 中的抽象方法 run(),在继承类中必须实现抽象类中的抽象方法
在抽象类Person中定义的是规则或规范,而在Student实现类类中是实现上面定义的规则和规范*/
public class Test {
public static void main(String [] args){
//Person p=new Person();
//多态的表现形式==(1)重载(2)覆盖(3)子类实例赋值给父类
//(4)子类实例可以赋值给父类的抽象类
Person p=new Student();//可以直接用子类来进行实现,也可以用父类可以实现,但是必须上转型对象吧子类的对象赋值给父类的对象。
// Person p;
// Student q=new Student();//父类不能使用子类新增的方法
// p=q;
p.add(1,0);//父类不能调用子类的新增方法,当子类重写了父类的方法是则调用子类的方法,当子类重载了父类的方法是调用父类的方法
// p.run();
// q.run();
// q.add();
}
}
//如果一个类是abstract,不一定里面的方法是abstract
public class TestAbstract1{
public static void main(String[] args){
//Animal a=new Animal(); //error
Animal a=null;
a=new Dog();
}
}
abstract class Animal{
}
class Dog extends Animal{
}
2.抽象方法:有方法名的定义,没有实现,(只定义了能做什么,没定义怎么做)
抽象方法的好处是允许方法的定义和实现分开。
abstract class Animal{
public abstract void eat();
}
抽象类和抽象方法的关系:含有抽象方法的类一定是抽象类,抽象类里不一定含有抽象方法
抽象类存在的意义是用来被继承的。一个类继承了一个抽象类,必须实现抽象类里面所有的抽象方法,否则,此类也是抽象类。
abstract class Animal{
public void run(){}
public abstract void sleep();
public abstract void eat();
}
class Dog extends Animal{
public void sleep(){
System.out.println("Dog sleep.");
}
public void eat(){
System.out.println("Dog eat.");
}
}
abstract class Cat extends Animal{
public void eat(){
System.out.println("Cat eat.");
}
}
可以声明父类类型子类对象,利用多态调用抽象方法
public class TestAbstract1{
public static void main(String[] args){
Animal a=null;
a=new Dog();
a.sleep();
a.eat();
}
}
抽象类有构造方法,有父类的,也遵循单继承的规律
class E{}
abstract class Animal extends E{
public Animal(){
super();
}
}
3.多种修饰符的连用问题:
public protected default private static final abstract
可以连用:
public static
private static
public final
public static final
不可以连用:abstract final void eat();
private abstract void eat();
static abstract void eat();
abstract不能和final,private,static连用
/*abstract定义类时方法必须完整的,为什么写不完整的方法,在程序实现过程中有时只要定义规范
不要求实现,写残缺的不完整的方法,你将一个方法定义为残缺的,说明这个类也是残缺的,类前也
要加abstract*/
abstract class Person
{
//public void run(); //方法是不完整的,
public abstract void run();
//抽象类中的实例方法必须实现,抽象方法不能进行实现。
public void add(int a,int b){
System.out.println("woshi");
};
}
//抽象类(abstract)只能拿来继承而不能进行实例化
class Student extends Person//子类必须覆盖父类的抽象方法
{
public void run(){
};
public void add(int a,int b,int c){
System.out.println("aaaaaaaaaaaaaa");
};
}
/*Student 不是抽象的,并且未覆盖 Person 中的抽象方法 run(),在继承类中必须实现抽象类中的抽象方法
在抽象类Person中定义的是规则或规范,而在Student实现类类中是实现上面定义的规则和规范*/
public class Test {
public static void main(String [] args){
//Person p=new Person();
//多态的表现形式==(1)重载(2)覆盖(3)子类实例赋值给父类
//(4)子类实例可以赋值给父类的抽象类
Person p=new Student();//可以直接用子类来进行实现,也可以用父类可以实现,但是必须上转型对象吧子类的对象赋值给父类的对象。
// Person p;
// Student q=new Student();//父类不能使用子类新增的方法
// p=q;
p.add(1,0);//父类不能调用子类的新增方法,当子类重写了父类的方法是则调用子类的方法,当子类重载了父类的方法是调用父类的方法
// p.run();
// q.run();
// q.add();
}
}
//如果一个类是abstract,不一定里面的方法是abstract