面向对象(oop)和继承

面向对象

本章类容

• 了解类和对象的关系
• 理解定义类和对象
• 构造函数
• 了解oop

概念

1. 对象：用来描述客观事物的一个实体，有一组属性和方法组成；是具体的真实存在的；
2. 属性：对象具有的各项特征；每个对象的每个属性都拥有特定值
3. 类：类是对象的概括，是对象的分类
   4.方法：对象执行的操作

发现类：确定新闻系统的类

1. 新闻系统的属性
2. 新闻系统的的方法
3. 代码：
   public class News {
   int id;
   String title;
   String content;
   String addUser;
   String imgPath;
   String pubDate;
   String isShow;
   public void addNews() {
   System.out.println(“你增加了一条新闻”);
   }
   public void updateNews() {
   System.out.println(“你更新了新闻”);
   }
   public void deleteNews() {
   System.out.println(“你删除了新闻”);
   }
   public void showNewsList() {
   System.out.println(“你展示了新闻列表”);
   }

}

封装：

1. 错误代码：Employee employee=new Employee();employee.age=1000;(代码赋值出现问题我们如何选择性的，选择代码的赋值，这时候就出现了封装，也就有了Private)
   2.封装：该类的某些信息影响隐藏在内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏类的访问和操作

2. 雇员类代码
   public class Employee {
   private int age;
   private String name;

   public String getName() {
   return name;
   }
   public void setName(String name) {
   this.name = name;
   }
   public Employee() {
   super();
   }
   public int getAge() {
   return age;
   }
   public void setAge(int age) {
   if (18<=age&&age<=60) {
   this.age=age;
   }else {
   this.age=18;
   }

   }
   public void say() {
   System.out.println(“该雇员的姓名是：\t”+name);
   System.out.println(“该雇员的年龄是：\t”+age);
   }
   }

3. 雇员类测试代码：
   import java.util.Scanner;
   public class EmployeeTest {
   public static void main(String[] args) {
   Scanner scanner=new Scanner(System.in);
   Employee employee=new Employee();
   System.out.println(“请输入你的年龄：”);
   int employeeAge=scanner.nextInt();
   System.out.println(“请输入名字：”);
   String employeeName=scanner.next();
   scanner.close();
   employee.setAge(employeeAge);
   employee.setName(employeeName);
   employee.say();
   }

}
5. 封装的作用：
- 信息的隐藏，提高了 程序的可读性和安全性
- 提供了程序的可重性
- 对象的数据封装特性彻底消除了传统结构方法中数据与操作分离所带来的种种问题，提高了程序的可复用性和可维护性，降低了程序员保持数据与操作内容的负担。
- 象的数据封装特性还可以把对象的私有数据和公共数据分离开，保护了私有数据，减少了可能的模块间干扰，达到降低程序复杂性、提高可控性的目的。

方法的重载

1. 两同一不同，同一个类型中方法名相同。参数不同，个数不同，顺序不同。

2. 实例: public Employee(String name,int age) {
   super();
   this.age = age;
   this.name = name;
   }
   public Employee() {

   }
   public Employee(int age, String name) {
   super();
   this.age = age;
   this.name = name;
   }

继承

为什么用继承？

1. 软件工程师类：private String no;
   private String name;
   private String enterTime;
   private String type;
   public void showInfo() {

   }
   public void coding() {

   }

2. 测试工程师类：public class TestEngineer {
   private String no;
   private String name;
   private String enterTime;
   private String level;
   public void showInfo() {
   }
   public void test() {
   }}
   
   • 这两个程序 有共同同的属性和方法，我过于复杂；我们可以通过继承来把方法和属性的公共部分作为父类，然后子类继承就可以的到。但是子类不能调用父类的私有属性和方法，只能调用公共的属性和公共的方法 。

3. 父类Engineer：public class Engineer {
   private String no;
   private String name;
   private String enterTime;

   public String getNo() {
   return no;
   }

   public void setNo(String no) {
   this.no = no;
   }

   public String getName() {
   return name;
   }

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

   public String getEnterTime() {
   return enterTime;
   }

   public void setEnterTime(String enterTime) {
   this.enterTime = enterTime;
   }

   public void showInfo() {
   System.out.println(“展示信息：”);

   }

}
2. 子类SoftEngineerOne：public class SoftEngineerOne extends Engineer {
private String type;

public String getType() {    return type;}public void setType(String type) {    this.type = type;}public void coding() {    System.out.println("我在写Bug");}

}
3. 子类TestEngineerOne：public class TestEngineerOne extends Engineer {
private String leave;

public String getLeave() {    return leave;}public void setLeave(String leave) {    this.leave = leave;}public void Test() {    System.out.println("我在debug");}

}
4. 继承的访问顺序：父类属性—>父类的构造方法—>子类属性—>子类的构造方法
5. 有些父类成员不能继承
- 子类不能访问父类private成员
- 子类与父类不在同包，使用默认权限的成员
- 构造方法

访问修饰符

• 可以修饰属性和方法
• 本类、同胞、子类可以访问
• 访问修饰符总结

访问修饰符 本类 同胞 子类 其他 private √ 默认（friendly） √ √ protect √ √ √ public √ √ √ √

方法的重写规则

• 在继承关系的子类
• 重写的方法名、参数、返回值类型必须和父类相同
• 私有方法不能继承 也不能重写
• 访问修饰符不能比父类更严格

方法重写和方法重载的比较

位置 方法名 参数表 返回值 访问修饰符 方法重写 子类 相同 相同 相同 不能比父类更严格 方法重载 同类 相同 不同 无关 无关1.

1. 父类Engnieer：public class Engineer {
public int no;
private String name;
private String enterTime;
public Engineer() {
// TODO Auto-generated constructor stub
System.out.println(“我是父类的构造函数”);
}

public String getName() {    return name;}public void setName(String name) {    this.name = name;}public String getEnterTime() {    return enterTime;}public void setEnterTime(String enterTime) {    this.enterTime = enterTime;}public void showInfo() {    System.out.println("展示信息：

“);

public showInfo();    System.out.println("我是测试工程承 ");}

}
2.子类SoftEngineer One：

public class SoftEngineerOne extends Engineer {
private String type;

public String getType() {    return type;}public void setType(String type) {    this.type = type;}public void coding() {    System.out.println("我在写Bug");}//重写：返回值类型，方法名和参数列表都要与父类相同//访问修饰符不能比父类更严格//私有方法不能继承因此也无法重写public void showInfo() {    /*super.showInfo();*/    System.out.println("我使软件工程师");}public String showInfo(int a) {        /*super.showInfo();*/        System.out.println("我使软件工程师");        String n="qb";

return n;

}

}

何时使用继承

继承与真实世界类似：符合is-a关系的设计使用继承