面向对象的三大特征——封装、继承、多态

Java面向对象学习笔记（第七篇[ps:本章涉及的内容为面向对象的三大特征（封装、继承、多态）]）

• 包：
  概念：物理上是文件夹，管理类
  作用：1.避免类重名 2. 按照不同的功能管理类 3. 控制访问权限
  命名规范：在包名中，可以使用.号来区分包的级别；包名一般情况下是小写
  第一级 指该项目的类型，如com,org,gov等，
  第二级 指项目所开发或者运行的公司名称，如：oracle,sun,huawei等
  第三级 指项目的名称，如：bcms,oa,erp,cms等
  第四级 指项目模块的名称，如：bean,action,exception等
  （包可以更好的管理逻辑相关的类，可以控制不同包之间的访问权限，一般要用import来导入外部包的类）
• 访问权限修饰符：
  1.public(公共权限)：修饰类、属性、方法。可以被任意类访问
  2.default(同包权限，默认可以不写)：修饰类、属性、方法。只能被同包的类访问
  3.protected(受保护的权限)：修饰属性方法。可以被同包类访问，如果不是同包类，必须是该类的子类才可以访问。
  4.private(私有权限)：修饰属性、方法。只能在本类中访问。
  

import java.util.Date;
/*
包的作用：1.避免类同名
        2.按照不同功能管理类
        3.控制访问权限
 */
public class Dome1 {
    //同一个包下不可引用相同类名
    public static void main(String[] args) {
        Date d = new Date();
        //如果要引用同类名的类，则需要写全类名
        java.sql.Date D = new java.sql.Date(1000);
    }
}

public class Dome2 {
    int num; //默认 修饰类、属性、方法,可以在同一个包类被访问
    public int pnum;//公共 修饰类、属性、方法，可以在同一个包类被访问，也可以跨包访问
    protected int pronum;//受保护 修饰属性、方法，可以在同一个包内被访问，跨包必须是其子类才可被访问
    private int prinum;//私有类 修饰属性，方法，只可以在同一个包内被访问

    public void text(){
        this.num = 1;
        this.pnum = 2;
        this.pronum = 3;
        this.prinum = 4;
    }
}

public class Dome3 {
    public static void main(String[] args) {
        Dome2 dome2 =new Dome2();
        System.out.println(dome2.num);
        System.out.println(dome2.pnum);
        System.out.println(dome2.pronum);
//        System.out.println(dome2.prinum);
    }
}

面向对象三大特征（封装、继承、多态）

1.**封装**：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问 封装的优点：1.隐藏类的实现细节。2.方便加入控制语句。3.方便修改实现.现。4.只能通过规定方法访问。

public class Person {
//定义私有属性进行封装
    private String name;
    private int age;
//   定义无参的构造方法
    public Person(){
    }
//    定义成员方法来对私有的属性进行操作
    public void setName(String n){
        if (n!=null){
            this.name = n;
        }
    }
//    定义方法来返回一个属性
    public String getName(){
        return this.name;
    }
    public void setAge(int a){
        if(a>0){
            this.age = a;
        }
    }
    public int getAge(){
        return age;
    }
}

public class person_text {
    public static void main(String[] args) {
        Person p = new Person();
        p.setName("乔峰");
        p.setAge(18);
        int a = p.getAge();
        a+=12;
        System.out.println(a);
        System.out.println(p.getName());
        System.out.println(p.getAge());
    }
}

2.继承：在已有类的基础上派生出新的类，新类可以拥有父类所有非私有属性和非私有方法。
作用：可提高代码的重用性和可扩展性。

public class Animal {
    private String name;
    private int age;

    public Animal() {
        System.out.println("父类的无参的构造方法");
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("父类的有参构造方法");
    }

    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 void eat(){
        System.out.println("觅食");
    }
}

@后面的一般都是Java注解，是Java中事先定义好的注解标签，作用在类、属性、方法上，用于标记。运行/编译时进行解析检测
@override重写 是在继承的时候，如果你写的函数与要继承的函数函数特征相同，
那么，加上这个关键字，在使用这个子类的这个函数的时候就看不见父类（或超类）的函数了，它被覆盖掉了。

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃老鼠");
    }
}

public class Dog extends Animal {
    private String type;
    public Dog(){
        super();
        System.out.println("子类的无参构造方法");
    }
    public void run(){
        super.setName("老帮主");
        System.out.println("跑的快");
    }
    public void eat(){
        System.out.println("敢吃屎");
    }
}

public class Test {
    public static void main(String[] args) {
            Dog dog = new Dog();
            dog.setName("乔峰");
            System.out.println(dog.getName());
            dog.eat();
        dog.run();
        System.out.println(dog.getName());
            Cat cat = new Cat();
            cat.eat();
    }
}

类之间的关系（关联，依赖）

关联关系：即“有”的关系（has - a）对象和对象直接的连接。关联关系分为单项关联和双向关联，单向关联即为A类关联B类；双向关联为A类关联B类且B类也关联A类。
关联关系的多重性：
1.一对一关联关系：例如：一个学生只能在一个班级里学习
2.一对多关联关系：例如：一个学生可以参加多个班级学习
依赖关系：（use - a）即一个类A使用到了另一个类
依赖关系的特性：这种关系时偶然性的、临时性的、非常弱的，但是类B的变化会影响到类A。

public class Preson {
    //人类和手机的关联关系 has-phone
    private String name;
//    private Phone phone;

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

//    public Phone getPhone() {
//        return phone;
//    }
//    public void setPhone(Phone phone) {
//        this.phone = phone;
//    }
    //人类和手机的依赖关系 use-phone1
        public void use(Phone phone1){
        //        this.phone = phone1;
            System.out.println(name+"会使用"+phone1.getType());
        }


}

public class Preson_Test {
    public static void main(String[] args) {
        Preson p1 = new Preson();
        Phone p2 = new Phone();
        p1.setName("乔峰");
        p2.setType("菲尔普斯山寨机");
        p1.use(p2);
    }
}

3.多态：同一种事务，在不同时刻表现不同的状态
多态存在的三个必要条件：1.要有继承（包括接口的实现）（前提条件）2.要有重写（前提条件）3.父类引用指向子类（父类名 变量名 = new 子类名）
抽象类：（类中有未实现功能的方法）被abstract修饰的类
如果一个类中含有抽象方法（没有实现的方法），那么这个类一定是抽象类；如果一个类是抽象类，它不一定要有抽象方法；如果一个类继承类抽象类：要么重写抽象类中的所有抽象方法。要么把当前类也声明为抽象类

public abstract class Animal {
    private String name;
    private int age;

    public abstract void eat(Animal animal);

    public static void run(Animal animal) {
        System.out.println("能跑");
    }

    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 class Cat extends Animal{

    @Override
    public void eat(Animal cat) {
        System.out.println("猫吃鱼");
    }
    public void ming(){
        System.out.println("猫有九条命");
    }
}

public class Dog extends Animal{
    private Animal type;

    @Override
    public void eat(Animal dog) {
        System.out.println("狗吃屎");
    }
    public void samell(){
        System.out.println("千里追踪，万里无极");
    }
}

public class Test {

    public static void main(String[] args) {
        Animal dog = new Dog();
        Animal cat = new Cat();
        dog.setName("乔峰");
        System.out.println(dog.getName());
        dog.eat(dog);
        Animal.run(dog);
        cat.setName("老帮主");
        if(cat instanceof Cat) {
            Cat cat1 = (Cat) cat;
            cat1.ming();
        }else {
            System.out.println("cat不包含Cat类型");
        }

        if(dog instanceof Dog) {
            Dog dog1 = (Dog) dog;
            dog1.samell();
        }
        else{
            System.out.println("dog不包含Dog类型");
        }
    }
}

final 用于声明属性、方法和类
修饰属性是时：定义了就必须直接赋值或者在构造方法中进行赋值，一般将其修饰为static，节省了空间，所有对象共享一份。（finla修饰的类不能被其他类继承）

//final定义修饰的类不能被其他类继承
public final class Pig{
    //final定于的属性为常量，定义时必须赋值或者在构造方法中赋值，一般将其修饰为static,节省了内存空间，所有对象共享一份
    final static String type = "荷兰香猪";
    final int time;

    public Pig(int time){
        this.time = time;
    }
    //final修饰的方法不能被其他方法重写（覆盖）
    public final String eat(){
        String str = "爆烤的荷兰烤乳猪很香";
        return str;
    }
    public static void main(String[] args){
        Pig p = new Pig(1);
        System.out.println("经过"+p.time+"个小时"+p.eat());
    }
}