面向对象特征

面向对象特征

面向对象语言三大特征:

1.封装

一般意义的封装，例如将重复出现的代码抽取了一个函数，称为代码的封装。

面向对象语言中的封装

将类中的某些信息，使用不同的访问权限修饰符隐藏在内部，不允许外部程序直接访问而是通过对类中向外提供的方法来实现对隐藏信息的操作和访问，方便加入控制语句，将主动权掌握在类自己手中。

封装案例一：将类中成员变量私有化

package Javademo;

public class Persons {
    private  String name;
    private  int age;
    public void setName(String name){
        if(name.length()>2&&name.length()<5){
            this.name=name;
        }
    }
    public String getName(){
        return this.name;
    }
    public void setAge(int age){
     if(age>0&&age<120){
         this.age=age;
       }
    }
    public int getAge(){
        return this.age;
    }
}

package Javademo;

public class TestPersons {
    public static void main(String[] args) {
        Persons persons= new Persons();
        persons.setName("张三");
        System.out.println(persons.getName());
        persons.setAge(50);
        System.out.println(persons.getAge());
    }
}

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

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

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

将类的构造方法私有化，在外界就不能随意的调用了，向外界提供一个获取该类对象的方法

package Javademo;

public class World {
    static World world=new World();//创建一个对象，将对象静态，此时在类中只有一份
   //无参的构造方法，设置为私有权限
    private World() {

    }
public  static World setWorld(){//公共权限，以此来调用，使外界可以使用此对象
        return world;
   }
}

package Javademo;

public class TestWorld {
    public static void main(String[] args) {
      World a=  World.setWorld();
      World b=  World.setWorld();
      World c=  World.setWorld();
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
       //输出的结果只有一种，因为在内部对象是静态变量，所以只有一件
    }
}

成员变量和局部变量

在类中的位置不同，按照位置分：

成员变量：

在类中定义 ，可以使用权限修饰符，在构造方法中进行自动的初始化赋值

生命周期：

非静态：随着对象的创建，随着对象的销毁而销毁

静态：随着类的加载而加载，随着类的销毁而销毁

存储的位置：

非静态：堆

静态：方法区

局部变量：

在方法中定义或者方法的参数

不可以使用权限修饰符，必须我们自己对其初始化赋值

生命周期：

随着方法的调用而存在，随着方法的调用完毕而消失

存储的位置：

栈

2.继承

将同一类事物中共性的属性和行为进行抽取，定义在一个类中（基类），其他类可以继承基类，就可以拥有基类中的功能

实现代码的复用性，以及可以在子类中扩展自己特有的功能，而不影响其他类。

只要符合is-a(什么是什么)关系的设计，就可以继承

优点：提高了代码的复用性

有利于功能的扩展

子类使用extends关键字继承另一个类

一个类只能继承一个类，间接的继承多个类，称为继承的传递性

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

package Javademo1;

public class Zhu extends Son {
    public void eat(){
        System.out.println("奥里给");
    }
    public void  look(){
        System.out.println("看大门");
    }
}

@Override是java中定义的注解标签,定义在重写的方法上面，表示此方法是从父类重写而来,用来检测是不是满足重写方法的要求。

package Javademo1;

public class Gou extends Son{
    @override
    public void eat(){
        System.out.println("爱看美妞");
    }
    public void  look(){
        System.out.println("给我看大门");
    }
}

当一个类没有显示的继承，那么这个类默认继承自Odject类

Object类是java类体系中最大的类，Object之上没有其他类

package Javademo1;

public class Son extends Object {
   private String name;
    private int age;
    
    public void eat(){
        System.out.println("爱睡觉");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        if(name.length()>2&&name.length()<5){
            this.name = name;
        }
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age>0&&age<1000) {
            this.age = age;
        }
    }
}

方法重写：

当父类中方法的实现不能满足子类需求时，可以在子类中对父类的方法进行重写（覆盖），这样调用时就会调用子类中重写的方法

方法重写的要求：

子类重写的方法的结构与父类方法的结构必须一致

方法名，参数列表，返回值必须一致

访问权限应等于或大于父类方法权限

package Javademo1;

public class TestSon {
    public static void main(String[] args) {
        Zhu zhu=new Zhu();
        zhu.setName("张三");
        System.out.println(zhu.getName());
        zhu.setAge(18);
        System.out.println(zhu.getAge());
        zhu.eat();
        zhu.look();
        Gou gou = new Gou();
        gou.setName("李四");
        System.out.println(gou.getName());
        gou.setAge(18);
        System.out.println(gou.getAge());
        gou.eat();
        gou.look();
    }

}

super关键字

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

访问父类中的属性和成员方法

super 在子类中用来调用父类中的成员

不要把super误认为是父类对象，在创建一个子类对象时，没有创建父类对象，只是将父类对象中的信息加载到子类对象中存储

package Javademo1;

public class Gou extends Son{
    public Gou() {
        super();
    }
    public  Gou(String name,int age){
        super(name,age);
    }

    @Override
    public void eat() {
        super.eat();
    }

    @Override
    public void  look(){
        super.look();
    }
}

package Javademo1;

public class Son extends Object{
   private String name;
    private int age;
    public Son(){

    }
    public void eat(){
        System.out.println("爱睡觉");
    }
    public Son(String name,int age){
        this.name=name;
        this.age=age;
        System.out.println(this.name+this.age);
    }

    public void  look(){
        System.out.println("给我看大门");
    }
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

}

package Javademo1;

public class TestSon {
    public static void main(String[] args) {
       Gou gou= new Gou("朱师磊",18);
        gou.eat();
        gou.look();
    }

}

抽象类：

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

一个类中如果包含抽象方法，这个类必定是抽象类。一个类是抽象类，不一定包含抽象方法

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

只是定义了一个方法，没有具体实现

抽象类中可能包含抽象方法，抽象方法不完整，所以类也是不完整的

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

主要在上层定义功能，让子类继承实现，一个子类如果继承了抽象类，要么重写抽象类中所有抽象方法，要么将该类也定义为抽象类

package Javademo2;

public abstract class Animal {
    private  String name;
    private int age;
    public Animal(){

    }
    public Animal(String name,int age){
        this.name=name;
        this.age=age;
    }
    public abstract void eat();
    public void look(){
        System.out.println("看大门");
    }
}

package Javademo2;

public  class Cat extends Animal {
    public Cat() {
        super();
    }
public Cat(String name,int age){
        super(name,age);
}
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    @Override
    public void look() {
        super.look();
    }
}

package Javademo2;

public class TestAnimal {
    public static void main(String[] args) {
       Cat cat=new Cat("李四",18);
    }
}

3.多态

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

父类引用指向子态对象，从而产生多种形态

前提必须要有继承关系

两个不同时间段：

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

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

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

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

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

变量不存在被子类覆写，只有方法可以

静态成员方法不能重写，编译和运行都看左边

将子类类型都转为父类类型，便于程序的扩展，

但是也存在一些问题：

一旦转为父类类型，就不能使用子类中特有的方法

解决方法：向下转型

将父类类型转为子类类型

Animal dog=new Dog();
Dog d=(Dog) dog;

package Javademo3;

public class Animal {

}

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

父类类型 instanceof具体子类类型 --true 否则--false

package Javademo3;

public class Cat  extends Animal{
    public void eat(){
        System.out.println("猫吃东西");
    }
    public void run(){
        System.out.println("猫抓老鼠");
    }
}

package Javademo3;

public class Dog extends Animal {
   public void eat(){
    System.out.println("狗吃东西");
    }
    public void look(){
        System.out.println("gou看大门");
    }
}

package Javademo3;

public class BX  {
    public  void PutAnimal(Animal animal){
        System.out.println("把动物装进冰箱");
        if (animal instanceof Dog){
            Dog d=(Dog)animal;
            d.eat();
            d.look();
        }
        if (animal instanceof Cat){
            Cat c=(Cat) animal;
            c.eat();
            c.run();
        }
    }
    public void  PutDX(Object object){
        System.out.println("把东西装进冰箱");
    }

}

package Javademo3;

public class Test {
    public static void main(String[] args) {
        Animal dog=new Dog();
        Animal cat=new Cat();
        BX bx=new BX();
        bx.PutAnimal(dog);
        bx.PutAnimal(cat);
        bx.PutDX(1);
    }
}

final关键字

final修饰 类，方法，参数，属性

被final修饰的类是不能继承的，所以不能修饰抽像类

例如java中的String就是被final修饰的

final修饰的方法不能被重写

final修饰方法的参数，参数值在方法中不能被改变

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

package Javademo3.day1;

public  class  Demo {
    final static int A=4;
    final  int COUNT;
    public Demo(){
        COUNT=10;
    }
    public Demo(int COUNT){
        this.COUNT=COUNT;
    }
    public final void eat(){
        System.out.println("天天开心");
    }

    public static void main(String[] args) {
        Demo demo=new Demo(20);
        System.out.println(demo.COUNT);
        System.out.println(demo.A);
        Demo demo1=new Demo();
        System.out.println(demo1.COUNT);
        System.out.println(demo1.A);
    }

}

接口

implements关键字

接口是计算机领域的名词，表示一种功能的定义

例如USB接口 定义USB接口的规范，让其他设备去实现

接口可以看作是一种特殊的抽像类，里面也可以包含抽像方法。

接口不能被创建对象，被其他类实现，重写抽象方法

主要也是用来定义功能

类实现接口类，要么重写接口中所有的抽象方法，要么将该声明为抽象类

package Javademo3.day2;

public interface MyInterface extends InterfaceA{
    int num=10;  //public  static  final  int num=10;
    void eat();  //public abstract void eat();
    //静态方法
    public  static void look(){

    }
    //默认方法
    default void looks(){

    }

}

一个类可以直接继承一个类

一个类可以实现多个接口

一个接口可以继承多个类

package Javademo3.day2;

public interface MyInterface extends InterfaceA{
    int num=10;  //public  static  final  int num=10;
    void eat();  //public abstract void eat();
    //静态方法，可以直接调用
    public  static void look(){

    }
    //默认方法
    default void looks(){

    }

}

package Javademo3.day2;

public interface InterfaceA {
    void Age();
}

 package Javademo3.day2;

public interface InterfaceB {
    void Name();
}

package Javademo3.day2;

public class Face extends Object implements MyInterface,InterfaceB{
    @Override
    public void eat() {
        
    }

    @Override
    public void looks() {

    }

    @Override
    public void Age() {
        
    }

    @Override
    public void Name() {
        
    }
}

接口和实现类之间存在多态类

package Javademo3.day2;

public class Test {
    public static void main(String[] args) {
        MyInterface myInterface=new Face();
    }
}

案例

王者荣耀

package Javademo3.day3;

public class Hero {
    private String name;
    private String occupation;

    public Hero(){

    }

    public Hero(String name, String occupation) {
        this.name = name;
        this.occupation = occupation;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getOccupation() {
        return occupation;
    }

    public void setOccupation(String occupation) {
        this.occupation = occupation;
    }

}

package Javademo3.day3;

public class Warrior extends Hero implements Power {
    @Override
    public void knife() {
        System.out.println("强大的man");
    }
}

package Javademo3.day3;

public class Wild extends Hero implements Attack{
    @Override
    public void sword() {
        System.out.println("偷袭的man");
    }
}

package Javademo3.day3;

public class Archer extends Hero implements Obscene{
    @Override
    public void gun() {
        System.out.println("猥琐的man");
    }
}

package Javademo3.day3;

public interface Power {
    void knife();
}

package Javademo3.day3;

public interface Attack {
    void sword();
}

package Javademo3.day3;

public interface Obscene {
    void gun();
}

package Javademo3.day3;

public class Test {
    public static void main(String[] args) {
        Hero hero1 = new Warrior();
        Hero hero2 = new Wild();
        Hero hero3 =new Archer();
        Power power=new Warrior();
        Attack attack= new Wild();
        Obscene obscene = new Archer();
        hero1.setName("马超");
        System.out.println(hero1.getName());
        hero1.setOccupation("战士");
        System.out.println(hero1.getOccupation());
        power.knife();

        System.out.println("===================");
        hero2.setName("李白");
        System.out.println(hero2.getName());
        hero2.setOccupation("刺客");
        System.out.println(hero2.getOccupation());
        attack.sword();

        System.out.println("===============");
        hero3.setName("公孙离");
        System.out.println(hero3.getName());
        hero3.setOccupation("射手");
        System.out.println(hero3.getOccupation());
        obscene.gun();
    }
}