我对封装、继承、抽象类和接口的一些简单理解

本人JAVA新人，正努力学习中

如果理解有不对，或者有更好的理解，欢迎指出

一、封装

书面理解：封装就是隐藏实现细节，把对象的信息和内部的逻辑结构隐藏起来，对外提供公共的访问方式。

形象的理解：封装就是做房子的时候将房子四周包的严严实实，里面有什么东西，只有作为主人的我知道。对外提供窗户和门来访问，但他们无法知道房子里面是什么样，不知道房子内的具体细节。

所以封装的好处主要就是安全性，和复用性。

关键字 private

package com.lenovo.demo;
/*
private:
是一个权限修饰符
可以修饰成员变量和成员方法
被其修饰的成员只能在本类中被访问
*/
public class Demo {
//int num = 10;用private修饰
private int num = 10;


public void show() {
System.out.println(num);
}


private void method() {
System.out.println("method");
}


public void function() {
method();
}


public int getNum() {
return num;
}


public void setNum(int num) {
this.num = num;
}
}

public class PrivateDemo {
public static void main(String[] args) {
Demo d = new Demo();
//不能访问私有的成员变量
//System.out.println(d.num);
System.out.println(d.getNum());
d.show();
d.setNum(20);
System.out.println(d.getNum());
d.show();
//不能访问私有的成员方法
//d.method();
d.function();
}
}

二、继承

继承的理解：

把多个类中相同的成员给提取出来定义到一个独立并公共的类中。然后让这多个类和该独立的类产生一个关系，

这种关系，称之为继承。

继承体现的是：is a的关系。

继承的好处：提高了代码的复用性和维护性。

继承的弊端：1.让类的耦合性增强。这样某个类的改变，就会影响其他和该类相关的类。

（原则：低耦合，高内聚。耦合：类与类的关系内聚：自己完成某件事情的能力）

2.打破了封装性

继承中的成员关系：

1.成员变量

子类的成员变量名称和父类中的成员变量名称一样时， 子类的方法访问变量的查找顺序：

在子类方法的局部范围找，有就使用。

在子类的成员范围找，有就使用。

在父类的成员范围找，有就使用。

找不到，就报错。

2.构造方法

a.子类的构造方法默认会去访问父类的无参构造方法

是为了子类访问父类数据的初始化

b:父类中如果没有无参构造方法，怎么办?

子类通过super去明确调用带参构造

子类通过this调用本身的其他构造，但是一定会有一个去访问了父类的构造

让父类提供无参构造

3.成员方法

子类的成员方法和父类中的成员方法名称一样时， 通过子类对象访问一个方法的查找顺序：

在子类中找，有就使用

在父类中找，有就使用

找不到，就报错

注： 1. Java中类只支持单继承

2.Java中可以多层(重)继承(继承体系)

3.子类不能继承父类的私有成员

4.子类不能继承父类的构造方法，但是可以通过super去访问

5.不要为了部分功能而去继承

关键字为 extends

格式 public class 子类名 extends 父类名 {}

//定义动物类
public class Animal {
//姓名
private String name;
//年龄
private int age;
//颜色
private String color;

public Animal() {}

public Animal(String name,int age,String color) {
this.name = name;
this.age = age;
this.color = color;
}

public String getName() {
return name;
}

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

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public String getColor() {
return color;
}

public void setColor(String color) {
this.color = color;
}

public void eat() {
System.out.println("不要睡了,该吃饭了");
}
}


//定义猫类
public class Cat extends Animal {
public Cat() {}

public Cat(String name,int age,String color) {
super(name,age,color);
}

public void playGame() {
System.out.println("猫玩英雄联盟");
}
}

//测试类
public class ExtendsTest {
public static void main(String[] args) {
//测试猫
//方式1
Cat c1 = new Cat();
c1.setName("Tom");
c1.setAge(3);
c1.setColor("白色");
System.out.println("猫的名字是："+c1.getName()+";年龄是："+c1.getAge()+";颜色是："+c1.getColor());
c1.eat();
c1.playGame();
System.out.println("---------------");

//方式2
Cat c2 = new Cat("杰瑞",5,"土豪金");
System.out.println("猫的名字是："+c2.getName()+";年龄是："+c2.getAge()+";颜色是："+c2.getColor());
c2.eat();
c2.playGame();

}
}

三、抽象类

抽象类的理解：用abstract修饰了的类就是抽象类，抽象类主要用于一些父类不需要具体实现，只需要定义方法名，由其子类完成具体方法体的情况，同事

使用抽象类是对子类提供一种 约束。

抽象类的特点：

1.抽象类和抽象方法必须用关键字abstract修饰

2.抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类

3.抽象类不能实例化

4.抽象类的子类可以是一个抽象类，此时不需要重写所有抽象方法，是一个具体类。这个类必须重写抽象类中的所有抽象方法。

抽象类的成员特点：

1.成员变量：有变量，有常量

2.构造方法：有构造方法

3.成员方法：有抽象，有非抽象

注：

1.抽象类有构造方法，不能实例化，那么构造方法有什么用?

用于子类访问父类数据的初始化

2.一个类如果没有抽象方法,却定义为了抽象类，有什么用?

为了不让创建对象

3.abstract不能和哪些关键字共存

a:final 冲突

b:private 冲突

c:static 无意义

//定义员工类
public abstract class Employee {
//姓名、工号以及工资
private String name;
private String id;
private int salary;

public Employee() {}

public Employee(String name,String id,int salary) {
this.name = name;
this.id = id;
this.salary = salary;
}

public String getName() {
return name;
}

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

public String getId() {
return id;
}

public void setId(String id) {
this.id = id;
}

public int getSalary() {
return salary;
}

public void setSalary(int salary) {
this.salary = salary;
}

//工作
public abstract void work();
}


//普通员工类
public class Programmer extends Employee {
public Programmer(){}

public Programmer(String name,String id,int salary) {
super(name,id,salary);
}

public void work() {
System.out.println("按照需求写代码");
}
}


//经理类
public class Manager extends Employee {
//奖金
private int money; //bonus 奖金


public Manager(){}

public Manager(String name,String id,int salary,int money) {
super(name,id,salary);
this.money = money;
}

public void work() {
System.out.println("跟客户谈需求");
}

public int getMoney() {
return money;
}

public void setMoney(int money) {
this.money = money;
}
}


public class AbstractTest4 {
public static void main(String[] args) {
//测试普通员工
Employee emp = new Programmer();
emp.setName("林青霞");
emp.setId("czbk001");
emp.setSalary(18000);
System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary());
emp.work();
System.out.println("-------------");
emp = new Programmer("林青霞","czbk001",18000);
System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary());
emp.work();
System.out.println("-------------");

/*
emp = new Manager();
emp.setName("刘意");
emp.setId("czbk002");
emp.setSalary(8000);
emp.setMoney(2000);
*/
//由于子类有特有的内容，所以我们用子类来测试
Manager m = new Manager();
m.setName("刘意");
m.setId("czbk002");
m.setSalary(8000);
m.setMoney(2000);
System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney());
m.work();
System.out.println("-------------");

//通过构造方法赋值
m = new Manager("刘意","czbk002",8000,2000);
System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney());
m.work();
}
}

四、接口

接口的理解：只提供一些抽象方法，除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。同时也是一种约束的规范。

接口的特点：

1.:接口用关键字interface修饰

interface 接口名 {}

2.:类实现接口用implements修饰

class 类名 implements 接口名 {}

3.:接口不能实例化

4.:接口的实现类

a:是一个抽象类。

b:是一个具体类，这个类必须重写接口中的所有抽象方法。

接口的成员特点：

1.成员变量

只能是常量

默认修饰符：public static final

2.构造方法

没有构造方法

3.成员方法

只能是抽象的

默认修饰符：public abstract

//定义跳高接口
public interface Jumpping {
//跳高功能
public abstract void jump();
}


//定义抽象类
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 String getName() {
return name;
}

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

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

//吃饭();
public abstract void eat();

//睡觉(){}
public void sleep() {
System.out.println("睡觉觉了");
}
}


//具体猫类
public class Cat extends Animal {
public Cat(){}

public Cat(String name,int age) {
super(name,age);
}

public void eat() {
System.out.println("猫吃鱼");
}
}

//有跳高功能的猫
public class JumpCat extends Cat implements Jumpping {
public JumpCat() {}

public JumpCat(String name,int age) {
super(name,age);
}


public void jump() {
System.out.println("跳高猫");
}
}

public class InterfaceTest {
public static void main(String[] args) {
//定义跳高猫并测试
JumpCat jc = new JumpCat();
jc.setName("哆啦A梦");
jc.setAge(3);
System.out.println(jc.getName()+"---"+jc.getAge());
jc.eat();
jc.sleep();
jc.jump();
System.out.println("-----------------");

JumpCat jc2 = new JumpCat("加菲猫",2);
System.out.println(jc2.getName()+"---"+jc2.getAge());
jc2.eat();
jc2.sleep();
jc2.jump();
}
}