public class Main(){
  public static info(String s){//这样就把这句话封装了起来，访问修饰符也可以使用private（不过这种情况经常会和其它方式结合在一起使用的比较多）
  System.out.println(s);
  }

  public static void main(String[] args) {
    info("Hello World");
  }

}

（3）这样就能给我们就很简单的实现了输出函数的封装

再来看另外一个实例，写一个类，然后在另一个类中打印一个学生的姓名，性别，年龄等信息

public class StudentData {
  private String name;
  private int age;
  private String gender;

  //然后按下alt+shift+s，选择Gatters和Settlers，系统会自动生成封装的类
  public String getName() {
    return name;
  }
  public void setName(String name) {
     = name;
  }
  public int getAge() {
    return age;
  }
  public void setAge(int age) {
    this.age = age;
  }
  public String getGender() {
    return gender;
  }
  public void setGender(String gender) {
    this.gender = gender;

//还有另一种方式，这里的话， 你就不必再Test类中，一个个的的定义学生的信息参数了
//快捷键同上，找到Constructor using Fileds就可以，但是你要把三个参数的选项都勾上
  public StudentData(String name, int age, String gender) {
    super();
     = name;
    this.age = age;
    this.gender = gender;
  }
  }
}

这里我们写好了学生信息的类

再写另一个测试类（Test）

public class Test {
  public static void main(String[] args) {
    //这里我把这Test类和StudentData类放在了同一目录下
    StudentData s=new StudentData();//创建我们封装好的类的对象
    s.setAge(18);//这里调用我们封装好的类的方法
    s.setName("Gorit");
    s.setGender("male");
//第二种方式，一步到位  StudentData s=new StudentData("Gorit", 18, "male");//创建我们封装好的类的对象

    //这是一种字符串处理方法，把我们想要打印的东西全都存放到str中
    String str="姓名:"+s.getName()+" 性别:"+s.getGender()+" 年龄:"+s.getAge();
    System.out.println(str);
  }
}

文章编辑于

2019年4月4日00:20:48

二、继承

多个类中存在相同的属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只需继承那个类即可

这个单独的类成为父类，基类或者超类：这多个类可以成为子类或派生类

现在给定一个父类（Father）和子类（Son）

写父类的属性和方法，父类现在有100元，和会踢足球的属性

再写子类，子类直接继承父类的属性和方法，再另外写一个打篮球的方法

（1）子类继承父类

父类：

public class Father {
  public int money=100;

  public void play() {
    System.out.println("踢足球");
  }
}

子类：

继承的关键字是extends

public class Son extends Father{

  public void myMonye(int money) {//这里孩子就继承了父类的属性和方法
//    System.out.println(money);
    System.out.println(super.money);//两种方法均可以调用
  }

  public void playBasketball() {//子类另外增加自己的方法
    System.out.println("打篮球");
  }
}

创建一个测试类 Test

如果

public class Test {

  public static void main(String[] args) {
    // TODO Auto-generated method stub
      Son s=new Son();//创建子类的对象
      System.out.println(s.money);//孩子继承父亲的money
      s.play();
      s.playBasketball();
  }
}

（2）方法的重写

当子类和父类中的方法的的参数，返回值，方法名完全一致时，在子类中写的方法如果有变动，就会覆盖父类的方法，这样就成为”方法重写“

Tips：
1、父类的私有方法不可以被重写
2、子类重写父类方法的时候，访问权限不能更低，比如父类是public，子类就不能是protected
3、父类为static静态方法，子类也必须按照static静态方法重写

这个比较简单，只要子类的的方法实现的参数，方法名，返回值类型和父类是一模一样的，就可以进行重写

示例：

父类

public class A {
  public int sum(int number1,int number2) {//这是我们写的父类的两数之和的方法
    return number1+number2;
  }

  public void poj() {
    System.out.println("我是父类方法1");
  }
}

子类：

public class B extends A{

  @Override//这个虽然是个注释，但是添加上别人就知道这是重写的方法
  public int sum(int number1,int number2) {
    return number1+number2+1;
  }
  public void poj2() {
    System.out.println("我是子类");
  }
}

（3）抽象类

抽象类：

无法使用static，private，final修饰
抽象类之中可以定义抽象方法和普通方法

给定一个炸弹鸟的抽象类

package pojo1;

public abstract class Brid {
//  public void attack() {
//    System.out.println("鸟会攻击");
//  }
  public abstract void attack();

  public void play() {

  }
  //普通方法必须有方法体
  //抽象方法可以没有方法提
}

package pojo1;

public class BoomBird extends Brid{

  @Override
  public void attack() {
    // TODO Auto-generated method stub
    System.out.println("丢炸弹的鸟");
  }

}

package test;

import pojo1.BoomBird;
import pojo1.Brid;

public class BirdTest {
  public static void main(String[] args) {
    Brid b=new BoomBird();
    b.attack();
  } 
}

Java OOP 式编程_父类

三、接口（补充）

接口的一些特征
1、接口是某个事物对外提供一些功能的声明
2、接口常常和多台使用在一起，也解决了java中单一继承的问题
3、接口的关键字是——interface
4、一般使用接口生命方法或常量，接口中的方法只能声明，不能具体实现

接口的实现：

格式：interface 接口名{}

类实现接口用 impements 实现

格式：class 类名 implements 接口名{}

示例：

这里我们写一个防盗门的样例

分析：

防盗门具有门的属性和防盗铃的属性

代码实现;

为了方便，这三个文件我放在同一个包的下面

public interface Call {//这是实现门铃的接口
  //报警
  public void call();

}

public interface Protecte {

  //保护的接口
  public void pro();

}

//门
public class Door  implements Protecte,Call {//这里就解决了无法多继承的问题

  @Override
  public void call() {
    // TODO Auto-generated method stub
  }
  @Override
  public void pro() {
    // TODO Auto-generated method stub
  }
}

接口还允许多继承