一个菜鸟对封装，继承等的的简单认知

个人理解

1：封装

封装就是把对象的信息和内部的逻辑结构隐藏起来，不让外部类直接访问，不过可以通过setter和getter方法进行访问

举个简单的例子：就是用一个房子把对象的信息和内部的逻辑结构放进去，锁起来不让别人访问，而setter和getter方法就是房子的门或窗户

封装的好处：1.安全性  2.复用性。

 例题：

package com.lenovo.dmeo;

public class Demo {
 //int i=10;使用private修饰
 private int i=10;
 
 public void print(){
  System.out.println(1);
 }
 
 private void show(){
  System.out.println("封装");
 }
 

 public int getI() {
  return i;
 }

 public void setI(int i) {
  this.i = i;
 }
 
 
}

package com.lenovo.dmeo;

public class Privatetext {
 public static void main(String[] args) {
  Demo demo=new Demo();
  
  System.out.print("输出i=");
  //public修饰的成员方法可以正常调用
  demo.print();
  
  //private修饰的成员方法无法访问
    //demo.show();
   
}
}

2.继承

继承是从已有的类中派生出新类，新类能继承已有类的属性和方法，并能扩展新的能力

举个例子：马云的儿子马小云继承了他爸爸的财产（属性）和赚钱的方法（方法），而且马小云还去学了演技（扩展新的能力）

继承的特性：单一性和传递性

单一性：只能有一个父类，通俗说就是只能有一个爹

传递性：父类中的成员变量和成员方法传递到子类中

继承的好处：

1.打破了封装

2.提高了代码的复用性并且减少了代码量

继承关键字：extends

使用：public class Niao {}

           public class Dayan extends Niao{}

例题：

package com.lenvov.modal1;

/**
 * 父类：鸟
 * @author nk
 *
 */
public class Niao {
 private String name;

 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }
 
 public void eat(){
  System.out.println("我吃虫");
 }
 public void fly(){
  System.out.println("我会飞");
 }
}

package com.lenvov.modal1;

/**
 * 子类：大雁
 * @author nk
 *
 */
public class Dayan extends Niao{
 public void color(){
  System.out.println("我颜色比一般鸟深");
 }
 public void zui(){
  System.out.println("我的嘴比一般鸟大");
 }
}

package com.lenvov.modal1;

public class Text {

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Niao niao=new Niao();
  Dayan dayan=new Dayan();
  
  niao.eat();
  niao.fly();
  System.out.println();
  dayan.eat();
  dayan.fly();
  dayan.color();
  dayan.zui();
 }

}

3.抽象类

抽象类：由abstract修饰的类，抽象类中抽象方法没有方法体，抽象类不能被实例化，所以抽象类必须被继承，才能被使用， 抽象类主要用于一些父类不需要具体实现，只需要定义方法名，由其 子类完成具体方法体 的情况

例题：

package tushu;

/**
 * 抽象类
 * @author nk
 *
 */
public abstract class Books {
 public abstract void addbook();
 public abstract void removebook();
 public abstract void searchbook();
}

package tushu;

/**
 * 继承抽象类Books
 * @author nk
 *
 */
public class Book extends Books{
 @Override
 public void addbook(){
  System.out.println("添加成功");
 }
 @Override
 public void removebook(){
  System.out.println("删除成功");
 }
 @Override
 public void searchbook() {
  System.out.println("搜索成功");
 }
 
}

package tushu;

public class Text {

 public static void main(String[] args) {
  
  Bok book=new Book();
  book.addbook();
  book.removebook();
  book.searchbook();
 }

}

4.接口

接口的理解： 接口是用interface修饰的一个类，类里只有抽象方法

接口的特点：

接口无法被实例化，但可以被实现

接口用关键字interface修饰

interface 接口名 {}

类实现接口用implements修饰

class 类名 implements 接口名 {}

例题：

package usb;

/**
 * 飞翔的接口
 * @author nk
 *
 */
public interface Flyable {
 public void Fly();
}

package usb;

public class Bird implements Flyable{

 @Override
 public void Fly() {
  // TODO Auto-generated method stub
  System.out.println("翅膀是我身体的一部分，我会飞");
 }

}