java面向对象5

面向对象特征

面向对象语言的三大特征

1.封装，2.继承，3.多态，4.（抽象)

封装:

一般意义的封装，例如：将重复出现的代码抽取一段函数，称为代码的封装（包装）；

面向对象语言中的封装：将类的某些信息通过不同的访问权限修饰符隐藏在类内部，不允许外部程序直接访问，而是 通过类中向外提供的方法来实现对隐藏信息的操作和访问 。

方便加入控制语句，将主动权在类自己手中。

封装案例1：将类中的属性私有化

封装案例2：将类中的方法私有化

java设计模式：解决某种问题的固定的方法（算法）

单例模式：让一个类，在一个程序中只能创建一个对象。

将类的构造方法私有化，外界不能随意构造，再向外界提供一个可以访问唯一对象的方法。

public class Wind {
    //构造一个静态的唯一对象wind,在类加载时就已经创建好这个对象了
    static Wind wind =new Wind();
    private Wind(){//将构造方法私有化，外界无法随意构造。
    }
    public static Wind gotwind(){//公共的方法，以此来调用
        return wind;
    }
}
/*------------------------------------------------------------*/
public class Testwind {
    public static void main(String[] args) {
       // wind wind=new wind();此处无法构造一个对象.
        Wind a=Wind.gotwind();
        Wind a1=Wind.gotwind();
        System.out.println(a);
        System.out.println(a1);
    }
}

继承：

子类（使用）extends(关键字) {继承} 另一个类(基类)；

一个类只能直接继承一个类，间接的继承多个类。

子类继承父类后，拥有了父类的成员变量和方法，但不能拥有父类的私有属性和方法。

多个类（同一类事物）中存在相同属性和行为进行一个抽取，将这些内容定义到单独的一个类（基类）中，多个类中无需再定义这些属性和行为，只需要和抽取出来的类构成继承关系，就能拥有基类的功能，

实现代码的复用性，以及可以在子类中扩展子类自己的功能。

只要符合is-a（xx是XX）关系的设计，就可以继承。

提高了代码的复用性，减少了代码的冗余；增强了代码的扩展性。

当父类中方法不能满足子类的需求，可以在子类中对父类的方法进行重写（覆盖）。

这样调用时，就会调用子类中的重写方法。

方法重写要求：子类重写的方法的结构与父类方法的结构必须一致。方法名，参数列表，返回值

必须要一致，访问权限应等于或大于父类的访问权限，最好一致。

最好加上 @Override 是java一个注解标签，定义在重写方法上面，表示此方法是从父类重写而来的，也可以不用添加，只要重写的方法节构一致，也算正确的重写。

构造方法，静态方法不能重写，成员变量不存在重写。

/*-------------------------------------------------------*/
public class Cat {
    public void zhua(){
        System.out.println("抓老鼠");
    }
}
/*-------------------------------------------------------*/
public class Dog extends Anmile{
    public  void  lookhoom(){
        System.out.println("看家护院");
    }
    @Override//重构Anmile里的eat方法
    public void eat() {
        System.out.println("吃骨头");
    }
}
/*-------------------------------------------------------*/
public class XTQ extends Dog {
    //继承了Dog类，由于Dog类继承了Anmile类，XTQ也继承了Anmile类。
    public  String fly(){
        return "起飞";
    }
    @Override//重构的特殊标签
    public void eat() {
        System.out.println("吃蟠桃");
    }
}
/*-------------------------------------------------------*/
public class Anmile {
    private String name;
    private  int age;
public Anmile(){

}
    public void eat(){
        System.out.println("吃东西");
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
/*---------------------------------------------------------*/
import java.util.Scanner;
public class TestAnmile extends Object {//当一个类后没有显示的继承，默认其继承Object。
    // Object类是java体系中最大的类，Object之上在没其他的类
    public static void main(String[] args) {
        Scanner Scan =new Scanner(System.in);
        Dog dog=new Dog();//继承了Anmile后才能调用其中的功能。
        dog.setName("朱石磊");
        dog.setAge(18);
        //dog.name;父类的私有属性无法继承。
        System.out.print(dog.getName());dog.lookhoom();
        System.out.println(dog.getName()+"刚满"+dog.getAge()+"岁--");
        System.out.print(dog.getName());dog.eat();
        Cat cat =new Cat();//没继承了Anmile，不能调用其中的功能。
        cat.zhua();//只能调用Cat类中原有的方法。
        //cat.setage();//无法调用
        XTQ xtq =new XTQ();
        xtq.setName(Scan.next());
        xtq.getName();
        System.out.println("能力"+xtq.fly());
        xtq.setAge(10000);
        System.out.println(xtq.getName()+xtq.getAge()+"岁");
        System.out.print(xtq.getName());xtq.eat();
    }
}

多态：同一事物，在不同时刻表现不同的状态。

父类指向子类对象时，产生的多种状态。

父类的应用变量，指向子类对象。

构成多态。

两个时间段：

1.编译期：写代码时 类型是父类类型

2.运行期：运行代码时 类型是具体的子类类型

多态也称为向上转型，将子类类型转为父类类型。

用父类类型表示任意的子类类型对象，有利于程序扩展。

成员方法：编译看左边，运行看右边。

因为静态方法不能重写，

当父类，与子类中都有同名静态方法时，编译和运行时看左边。

成员变量，编译和运行都看的左边。

问题：一旦转为父类的类型，就不能调用到子类中特有的方法,需要向下转型，将父类向下转为子类类型。

instanceof表示父类类型中持有的实际类型，是否是指定类型。

final关键字

以final来定义常量，还可以修饰 类、方法、参数、和成员变量（修饰后为常量）。

final修饰的类不能被继承，不能修饰抽象类。

final修饰的方法 不能被重写；

final修饰方法的参数，参数不能在方法中被改写；

final修饰的成员变量值不能改变，因此被称为常量。

常量建议用大写。

super关键字:

在java中使用Super可调用父类的指定操作。

访问父类中定义的属性，成员方法，以及子类构造器中调用的父类的构造器。

this与super用法相似，this代表本类对象的引用，super代表父类的内存空间标识。但要分清，this表示当前对象，super表示调用父类中的成员，而不是父类对象。

继承中的构造方法：

子类继承父类时，不会继承父类的构造方法。只能通过“super(形参列表)” 的方式调用父类指定的构造方法，规定super(形参列表)，必须声明在构造方法的首行，子类构造方法的首行没有显示调用super(形参列表)，则子类此构造方法 默认调用super()，即调用父类中空参的构造方法。

public class TestAnmile {
    public static void main(String[] args) {
        Dog dog = new Dog();
        Dog dog1 =new Dog("aaa",2);
    }
}
/*-----------------------------------------*/
public class Dog extends Anmile {
    public Dog(){
        //默认有一个supe();
        System.out.println("Dog中的无参构造");
    }
    public Dog(String name,int age){
        super(name,age);//调用有参的构造方法
        System.out.println("Dog中的有参构造");
    }
}
/*------------------------------------------*/
public class Anmile {
    private String name1;
    private  int age1;
    public  Anmile(){//父类中如果没有无参的构造方法的话,子类中没法调用
        System.out.println("Anmile中的无参构造");
    }
    public  Anmile(String name, int age){
        System.out.println("Anmile中的有参构造");
    }
}

抽象类

抽象方法：是一种只有方法声明，而没有具体的实现的方法。抽象方法必须用abstract关键字进行修饰。

抽象方法在一些体系结构的顶端类中，有些功能没必要实现，因为不同子类中的实现都不同。这是就可将方法定义为抽象方法。

抽象方法，没有方法体，使用abstract修饰。

使用abstract修饰的类，就是抽象类；

一个类中包含抽象方法，则这个类一定为为抽象类，抽象类中可能包含抽象方法，抽象方法不完整，所以类也是不完整的。

抽象类不能创建对象，其他功能与正常的类都相同。可以有成员变量，成员方法，构建方法。

主要在上层定义功能，让子类继承实现。

一个子类如果继承抽象类，要么重写抽象方法，要么将该类也定义为抽象类。