抽象类

含有抽象方法的类就是抽象类

1) 抽象方法：该方法有返回值，有参数，就是没有方法体，该方法没有方法实现

2) 抽象方法的格式：

abstract 返回值类型 方法名(参数列表)；

3) 抽象类需要靠子类来重写抽象方法，以实现其功能

public classTest1 {//抽象类：含有抽象方法的类//抽象方法：没有方法体的方法

public static voidmain(String[] args) {

Taxi taxi=newTaxi();

taxi.name="出租车";

taxi.start();

taxi.run();

taxi.stop();

}

}//定义一个抽象类Car：属性：名字，价格，速度//方法：启动，运行，刹车，全是抽象方法

abstract classCar{

String name;doubleprice;intspeed;public abstract voidstart();public abstract voidrun();public abstract voidstop();

}class Taxi extendsCar{//抽象类是依靠子类，来实现其功能(子类重写抽象方法)

public voidstart() {

System.out.println(name+"行驶");

}public voidrun() {

System.out.println(name+"启动");

}public voidstop() {

System.out.println(name+"刹车");

}

}

4) 抽象类不能直接实例化(创建对象)

public classTest1 {public static voidmain(String[] args) {//Foo1 foo1=new Foo1();---报错

}

}abstract classFoo1{abstract voidshow();

}

5) 可以使用抽象类声明一个对象，然后利用该抽象类的子类来创建对象

格式：抽象类 对象名-->定义对象

对象名=new 子类构造方法-->创建对象

抽象名 对象名=new 子类构造方法

public classTest1 {public static voidmain(String[] args) {

Koo1 koo1=new Koo2(); //抽象类名(父类) 对象名=new 子类的构造方法

koo1.show();

}

}abstract class Koo1{//父类---声明(定义)对象

public abstract voidshow();

}class Koo2 extends Koo1{//子类---创建对象

public voidshow() {

System.out.println("昨天下雨了");

}

}

6) 父类声明指向子类引用

格式：父类 对象=new 子类的构造方法

编译时(javac)           运行时(java)

用这种方式创建的对象，可以访问父类的除重写以外所有的方法，可以访问子类重写父类的方法

唯一不能做的事，就是访问子类独有的方法

public classTest1 {public static voidmain(String[] args) {

Eoo eoo=newEoo2();

eoo.show();//访问子类中重写父类的方法

eoo.print();//父类中的普通方法//eoo.speak();---报错//不能访问子类独有的方法

}

}classEoo{voidshow(){

System.out.println("今天是个好天气");

}voidprint(){

System.out.println("今天是周一");

}

}class Eoo2 extendsEoo{voidshow(){

System.out.println("天气好好");//重写

}void speak(){//子类独有的方法

System.out.println("说话");

}

}

7) 抽象类跟一般类是一样的，只是抽象类含有抽象方法(没有方法体的方法)

抽象类需要靠子类来重写所有的抽象方法，以实现其功能

创建对象：

1.直接使用子类来声明和创建对象

2.父类声明指向子类的对象

public classTest1 {public static voidmain(String[] args) {

Person person=new Worker("张",23,"男",5000);

person.print();

person.show();

}

}//设计Person类型，属性：姓名，年龄，性别//构造方法：1.空参的构造方法//2.带(姓名，年龄，性别)的构造方法//方法：show():显示姓名，年龄属性//抽象方法print();//设计Worker类型，属性：姓名，性别，年龄，工资//构造方法：给所有的属性赋值//方法：重写print()方法，显示该对象所有的属性//

abstract classPerson{

String name;intage;

String sex;

Person(){}

Person(String name,intage,String sex){this.name=name;this.age=age;this.sex=sex;

}voidshow(){

System.out.println(name+","+age);

}public abstract voidprint();

}class Worker extendsPerson{doublesalary;

Worker(String name,int age,String sex,doublesalary){super(name,age,sex);this.salary=salary;

}public voidprint() {

System.out.println(name+","+age+","+sex+","+salary);

}

}

设计模式---工厂模式(了解)

用一个类来帮我们创建和管理对象，就是工厂模式

public classTest1 {//工厂类中用来提供对象的方法，最好设计静态方法，易于调用

public static voidmain(String[] args) {

Emp emp=EmpFactory.getInstance();

emp.show();;

}

}classEmpFactory{public staticEmp getInstance(){

Emp emp=new Emp("刘",45);returnemp;

}

}classEmp{

String name;intage;

Emp(String name,intage){this.name=name;this.age=age;

}voidshow(){

System.out.println(name+","+age);

}

}

public classTest1 {public static voidmain(String[] args) {

Car car=CarFactory.getInstance(1);

car.name="Bmw";

car.show();

Car car1=CarFactory.getInstance(2);

car1.name="Benz";

car1.show();

}

}//设计一个父类Car，属性：名字//构造方法：空参构造方法，带名字的构造方法//方法：show显示该Car的名字//设计一个Car的子类Bmw，属性：速度//设计一个Car的子类Benz，属性：价格//设计一个Car的子类QQ，属性：颜色//设计一个工厂，可以根据用户的请求来创建不同的子类对象

classCar{

String name;

Car(){}

Car(String name){this.name=name;

}voidshow(){

System.out.println(name);

}

}class Bmw extendsCar{intspeed;

}class Benz extendsCar{doubleprice;

}class QQ extendsCar{

String color;

}//分析：参数来代表用户不同的请求//1---BMZ,2---Benz,3----QQ//工厂中获得对象的方法，可以根据调用参数的不同，返回不同的Car的子类对象

classCarFactory{public static Car getInstance(inttype){

Car car=null;if(type==1){

car=newBmw();

}else if(type==2){

car=newBenz();

}else if(type==3){

car=newQQ();

}returncar;

}

}