Java学习笔记之---面向对象

（一）封装

（1）封装的优点

良好的封装能够减少耦合。
类内部的结构可以自由修改。
可以对成员变量进行更精确的控制。
隐藏信息，实现细节。

（2）实现封装的步骤

1. 修改属性的可见性来限制对属性的访问（一般限制为private）

 private String sex;

2. 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问

 public void setSex(String s){

    this.sex=s;

}

public String getSex(){

    return sex;

}

3.可以在set方法中添加条件

 public void setSex(String s){

    if(sex=="男"||sex=="女"){

        sex=s;

    }else{

        sex="男";

    }

}

  public String getSex(){

    return sex;

}

（3）封装实例

public class Dog {

    String name;

    String color;

    int age;

    private String sex;

    public void setSex(String s){

        if(sex=="男"||sex=="女"){

            sex=s;

        }else{

            sex="男";

        }

    }

    public String getSex(){

        return sex;

    }

    public void eat(){

        System.out.println("吃饭");

    }

}

 class test{

    public static void main(String[] args){

     Dog dog3=new Dog();

     dog3.name="cc";

     dog3.age=100;

     dog3.setSex("男");

     dog3.eat();

     System.out.println("狗3的性别为："+dog3.getSex());

    }

}

（二）继承

（1）什么是继承

继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。
继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

（2）继承格式

class 父类 { }

class 子类 extends 父类 { }

（3）继承的优点

减少代码的重复，使代码更加整洁
提高维护性
提高代码的复用性

（4）继承的类型

单继承
多重继承
不同类继承同一个类
一个类不能继承多个类

（5）继承的特性

父类中的构造方法不能被继承，如果父类中有无参构造方法子类中也要有
子类可以继承父类的属性和方法
子类继承父类的方法后可以进行重写
父类中私有的不能被继承

（6）继承实例

public class Office {

    public void print(){

        System.out.println("打印");

    }

}

public class Excel extends Office {

    public void print(){

        System.out.println("Excel打印");

    }

}

（三）多态

（1）什么是多态

多态是同一个行为具有多个不同表现形式或形态的能力。
多态就是同一个接口，使用不同的实例而执行不同操作
多态性是对象多种表现形式的体现

（2）多态的优点

1. 消除类型之间的耦合关系

2. 可替换性

3. 可扩充性

4. 接口性

5. 灵活性

6. 简化性

（3）多态存在的必要条件

1.继承 2.重写 3.父类引用指向子类对象

（4）多态实例

1.创建一个父类和两个子类，子类继承父类的属性和方法

public class Animal {

    String name;

    String age;

    public void eat(){

        System.out.println("吃饭");

    }

}

public class Cat extends Animal {

}

public class Dog extends Animal {

}

2.子类对父类方法进行重写

public class Dog extends Animal {

    public void eat(){

        System.out.println("狗吃饭");

    }

}

public class Cat extends Animal {

    public void eat(){

        System.out.println("猫吃饭");

    }

}

3.父类引用指向子类对象

class test{

    public static void main(String[] args){

      Animal a=new Cat();

    }

}

4.整体实例

public class Animal {

    String name;

    String age;

    public void eat(){

        System.out.println("吃饭");

    }

}

class test{

   public static void main(String[] args){
//向上转型，隐式转型，自动转型，父类引用指向子类对象，可以调用子类重写父类的方法以及父类派生的方法，无法调用子类独有的方法

 Animal a=new Cat();// 向上转型

 a.eat(); // 调用的是 Cat 的 eat
//向下转型，强制类型转换，子类引用指向父类对象，此处必须进行强转，可以调用子类特有的方法
  Cat b=(Cat) a; // 向下转型

  b.eat();// 调用的是 Cat 的 eat

  show(new Dog());// 以 Dog 对象调用 show 方法

}

    public static void show(Animal n){

        if(n instanceof Cat){

         Cat c=(Cat)n;

         c.eat();

        }else if(n instanceof Dog){

            Dog c=(Dog)n;

            c.eat();

        }

    }

}

public class Dog extends Animal {

    public void eat(){

        System.out.println("狗吃饭");

    }

}

public class Cat extends Animal {

    public void eat(){

        System.out.println("猫吃饭");

    }

}

（四）抽象类

（1）什么是抽象类

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类

（2）关键字

abstract

（3）抽象方法

如果一个类包含抽象方法，那么该类必须是抽象类。
任何子类必须重写父类的抽象方法，或者声明自身为抽象类

（4）抽象类的规则

抽象类不能被实例化(初学者很容易犯的错)，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。
抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能，抽象方法以分号结尾；
构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。
抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。
static，final，private不能与abstract并存

（5）抽象类实例

public abstract class Animal {

    String name;

    String age;

    public abstract void eat();

}

public class Cat extends Animal {

    public void eat(){

        System.out.println("猫吃饭");

    }

}

（五）接口

（1）什么是接口

接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法

（2）关键字

interface implement

（3）接口与类的相似点

一个接口可以有多个方法。
接口文件保存在 .java 结尾的文件中，文件名使用接口名。
接口的字节码文件保存在 .class 结尾的文件中。
接口相应的字节码文件必须在与包名称相匹配的目录结构中。

（4）接口与类的区别

接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法。
接口不能包含成员变量，除了 static 和 final 变量。
接口不是被类继承了，而是要被类实现。
接口支持多继承。

（5）接口与抽象类的区别

抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
一个类只能继承一个抽象类，而一个类却可以实现多个接口。

（6）接口的特性

接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。
接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字。
接口中每一个方法也是隐式抽象的，声明时同样不需要abstract关键字。
接口中的方法都是公有的。
接口中的方法如果想有方法体，可以借助default或者static实现

（7）接口的实例

  public interface Housekeeping {

    public void bark();

}

public class Dog implements Housekeeping {

   public void bark(){

       System.out.println("看见坏人会叫");

   }

}

（六）封装--继承--多态--抽象类--接口实例

1.封装

public class Animal {

  private String name;

  private String color;

  public void setName(String name){

      this.name=name;

  }

  public String getName(){

      return name;

  }

  public void setColor(String color){

      this.color=color;

  }

  public String getColor(){

      return color;

  }

  public void eat(){

     System.out.println("吃饭");

  }

}

class test{

    public static void main(String[] args){

        Animal a=new Animal();

        a.setName("aa");

        a.setColor("red");

        a.eat();

    }

}

运行结果：吃饭

2.继承

public class Animal {

  private String name;

  private String color;

  public void setName(String name){

      this.name=name;

  }

  public String getName(){

      return name;

  }

  public void setColor(String color){

      this.color=color;

  }

  public String getColor(){

      return color;

  }

  public void eat(String name){

     System.out.println(name+"吃饭");

  }

}

class test{

    public static void main(String[] args){

        Animal a=new Animal();

        a.setName("aa");

        a.setColor("red");

        a.eat(a.getName());

        Cat b=new Cat();

        b.setName("bb");

        b.setColor("blue");

        b.eat(b.getName());

    }

}

public class Cat  extends Animal{

   public void eat(String name){

    System.out.println("猫"+name+"在吃饭");

}

}

运行结果：

aa吃饭

猫bb吃饭

3.多态

public class Animal {

  private String name;

  private String color;

  public void setName(String name){

      this.name=name;

  }

  public String getName(){

      return name;

  }

  public void setColor(String color){

      this.color=color;

  }

  public String getColor(){

      return color;

  }

  public void eat(String name){

     System.out.println(name+"吃饭");

  }

}

class test{

    public static void main(String[] args){

        Animal a=new Animal();

        a.setName("aa");

        a.setColor("red");

        a.eat(a.getName());

        Cat b=new Cat();

        b.setName("bb");

        b.setColor("blue");

        b.eat(b.getName());

        Animal c=new Cat();

        c.setName("cc");

        c.setColor("yellow");

        c.eat(c.getName());

        Cat d=(Cat)c;

        d.eat(d.getName());

    }

}

public class Cat  extends Animal{

   public void eat(String name){

    System.out.println("猫"+name+"在吃饭");

}

}

运行结果：

aa吃饭

猫bb在吃饭

猫cc在吃饭

4.抽象类

public abstract class Animal {

  private String name;

  private String color;

  public void setName(String name){

      this.name=name;

  }

  public String getName(){

      return name;

  }

  public void setColor(String color){

      this.color=color;

  }

  public String getColor(){

      return color;

  }

  public void eat(String name){

     System.out.println(name+"吃饭");

  }

  public abstract void sleep();

}

class test{

    public static void main(String[] args){

        Cat b=new Cat();

        b.setName("bb");

        b.setColor("blue");

        b.eat(b.getName());

        Animal c=new Cat();

        c.setName("cc");

        c.setColor("yellow");

        c.eat(c.getName());

        c.sleep();

        Cat d=(Cat)c;

        d.eat(d.getName());

        d.sleep();

    }

}

public class Cat  extends Animal{

    public void eat(String name){

        System.out.println("猫"+name+"在吃饭");

    }

    public void sleep(){

        System.out.println("猫在睡觉");

    }

}

运行结果：

猫bb在吃饭

猫cc在吃饭

猫在睡觉

猫cc在吃饭

猫在睡觉

5.接口

public abstract class Animal {

  private String name;

  private String color;

  public void setName(String name){

      this.name=name;

  }

  public String getName(){

      return name;

  }

  public void setColor(String color){

      this.color=color;

  }

  public String getColor(){

      return color;

  }

  public void eat(String name){

     System.out.println(name+"吃饭");

  }

  public abstract void sleep();

}

class test{

    public static void main(String[] args){

        Cat b=new Cat();

        b.setName("bb");

        b.setColor("blue");

        b.eat(b.getName());

        Animal c=new Cat();

        c.setName("cc");

        c.setColor("yellow");

        c.eat(c.getName());

        c.sleep();

        ((Cat) c).dark();

        Cat d=(Cat)c;

        d.eat(d.getName());

        d.sleep();

        d.dark();

    }

}

public interface Housekeeping {

    public void dark();

}

public class Cat  extends Animal implements Housekeeping{

    public void eat(String name){

        System.out.println("猫"+name+"在吃饭");

    }

    public void sleep(){

        System.out.println("猫在睡觉");

    }

    public void dark(){

        System.out.println("猫在叫");

    }

}

运行结果：

猫bb在吃饭

猫cc在吃饭

猫在睡觉

猫在叫

猫cc在吃饭

猫在睡觉

猫在叫