面向对象特征

面向对象特征

封装概念：

隐藏类的信息，外部程序不可以访问，必须提供专门的方法对私有方法和私有属性访问，还可以给公共权限构造方法赋值访问

.特点：

只能通过指定的方法访问被封装的信息

隐藏类的信息

方便控制语句的加入

方便修改实现

this关键字

代表当前对象

使用this关键字可以引用成员变量

使用this关键字可以引用成员方法

*注意：*不能在静态方法里面使用this

package day4;

public class Person {
    //隐藏信息，外部程序不可以访问
    private String name;
    private int age;
    //可以用构造方法访问属性
    public Person(){}
    public  Person(String n,int a){   //公共权限构造方法赋值
        name=n;
        age=a;
    }
    //提供外界访问权限的成员方法
    public void setName(String  b){
        name=b;
    }
    public String getName(){
        return name;
    }
    public void setAge(int a){
        age=a;
    }
    public int getAge(){
        return age;
    }
}

package day4;

public class Text {
    public static void main(String[] args) {

        Person p1 = new Person();//调用有参的构造方法
    /*p.name="tao"
    p.age=10;*/    //因为属性被封装，所以不可以访问
        p1.setAge(10);
        p1.setName("张三");
        Person p2=new Person();
        System.out.println(p1.getAge());
        System.out.println(p1.getName());
        p2.setName("李四");
        p2.setAge(10);
        System.out.println(p2.getName());
        System.out.println(p2.getAge());
}
}

继承

从已有的类中派生出新的类，新的类可以继承已有类的属性和方法；还可以扩展新的属性和方法

使用extends关键字来表示继承关系。

没有多继承 一个类只能有一个直接父类

子类可以继承父类所有非静态方法和非静态属性

当有关系 is - a 时 可以表示继承关系 ： 猫是动物 狗是动物

继承形式：

[访问权限修饰符][修饰符] 子类名 extends 父类名{子类体}

package day4;
/**
  继承：
     在已有类的基础上，派生出新的类，新类可以拥有父类非私有的属性，方法
     提高代码可重用性，可扩展性

     是一种is-a关系   猫是动物，狗是动物
 Animal  称为  父类/基类
 */
public class Animal extends Object{

      private String name;
       private  int age;
       public void eat(){
           System.out.println("吃");
       }

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

    public int getAge() {
        return this.age;
    }

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

package day4;
/*
  在Animal的基础上派生出  狗类
       Java中一个类只能直接继承一个父类
 */
public class Dog extends Animal{
       private String type;
       public void study(){
           System.out.println("狗学习");
       }
       public void setType(String type){
           this.type=type;
       }
       public String getType(){
           return type;
       }
}

在上述代码中 父类为Animal 子类为Dog

术语中 父类为基类 子类为派生类

继承的传递性：

C类从B类继承,B类又从A类继承

那么C类就具有B类和A类的所有非私有属性和非私有方法

jvm一般默认类继承Object类

package day4;
/*
    子类 父类
     派生类  基类


     继承的传递性
        哮天犬
 */
public class xiaotianquan {
    public void fly(){
        System.out.println("狗会飞");
    }

}

package day4;

public class TextExtends {
    public static void main(String[] args) {
        Dog dog=new Dog();
        dog.setType("田园");
        System.out.println(dog.getType());
        dog.study();
        dog.eat();
        dog.setName("伟涛");
        System.out.println(dog.getName());
        xiaotianquan xtq=new xiaotianquan();
        xtq.fly();
    }
}

xioatianquan类继承了Dog类

同时它也继承了Animal类，即可以说Animal类是xiaotianquan类的爷爷（继承的传递性）

继承中的构造方法

子类构造方法总是先调用父类构造方法,默认情况下，调用父类无参构造方法

可以在子类构造方法的第一行，使用super关键字调用父类任意一个构造方法

如果用super,必须写在构造方法的第一句

如果子类的构造方法中没有显式地调用基类构造方法，则系统默认调用基类无参数的构造方法。

原因：子类创建后需要调用父类的方法,所以在创建子类对象是父类也需要同时被创建.（随着类的加载而加载）

package day5.demo1;
/**
  继承：
     在已有类的基础上，派生出新的类，新类可以拥有父类非私有的属性，方法
     提高代码可重用性，可扩展性

     是一种is-a关系   猫是动物，狗是动物
 Animal  称为  父类/基类
 */
public class Animal extends Object{
      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 void eat(){
           System.out.println("动物吃");
       }
       public void study(){
           System.out.println("动物学习");
       }
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return this.name ;
     }
    public int getAge() {
        return this.age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

方法的重写（Override）

在子类中可以根据需要对从基类中继承来的方法进行重写。

规则：方法名相同、参数列表相同；返回值类型相同；访问权限相同

即与父类方法结构完全相同

一般当父类的方法实现 不能满足子类需求时, 可以对方法进行重写

注意：

构造方法不能重写

package day5.demo1;

/*
  在Animal的基础上派生出  狗类
       Java中一个类只能直接继承一个父类

    子类创建一个构造方法时，先调用父类构造方法，默认情况下调用无参的构造方法。
    如果子类没有显式的构造方法，那么系统将调用基类的无参构造方法
    子类创建后需要调用父类的方法，所以创建子类对象时也要同时创建父类对象
 */
public class Dog extends Animal {
       private String type;

    public Dog() {
        //  super();   //使用super关键字可以调用任意的父类构造方法，必须写在第一行。如果没有参数，默认调用无参的构造方法
        super("jia",3);//如果要调用有参的构造方法，需要在super中加入参数
        System.out.println("子类无参构造方法");
    }
    /*
        当父类的方法实现不能满足子类的需求时，可以将父类中定义好的方法重写过来。
        方法的重写：
            方法名，参数列表
            返回值
            访问权限
            与父类方法的结构相同


   @Override   java注解   是java中事先定义好的一些注解标签
   作用：可以作用在类 ，属性 ，方法上，用于标记，运行时/编译时会进行解析检测
     */

    @Override//标注此方法是从父类重写而来
    public void eat() {
        System.out.println("狗吃骨头"); //子类自己扩展的功能
        super.eat();   //重用父类的功能
    }


    @Override
    public void study() {
        System.out.println("狗会学习");
        super.study();
    }

    public void setType(String type){
           this.type=type;
       }
       public String getType(){
           return type;
       }
}

package day5.demo1;

public class TextDog {
    public static void main(String[] args) {

        Dog dog = new Dog();
        dog.eat();
        dog.study();
    }
}

类之间的关系

关联关系

对象和对象之间的连接。

在Java中，关联关系的代码表现形式为一个类做为另一个类的属性类型存在。

一般“有”的关系 has-a（人有 手机）

关联关系分为：

单向关联：A类关联B类

双向关联：A类关联B类 B类关联A类

关联关系的多重性：

一对一关联：一个学生，只能在一个班级里学习。

一对多关联：一个学生，可以参加多个班级学习

依赖关系

A类使用到了B类

特性：

这种关系是具有偶然性的、临时性的、非常弱的，但是类B的变化会影响到类A。

A类依赖B类：B的对象作为A类的方法参数存在，“use”关系“十分弱 方法完成后变量立即销毁。

package day5.demo2;

import java.util.List;

/*
人类
 人有手机   关联关系     has-a
 关联关系分为单向关联和双向关联

 */
public class Person {
    String name;
    int age;
    Mobile mobile;//一对一关联
   /*  一对多关联
    private Mobile[] mobiles;
    private List<Mobile> mobileList;*/

 /*   public Person(Mobile mobile) {
        this.mobile = mobile;
    }*/
    public void call(){
        mobile.tonghua();
        System.out.println("电话");
    }

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

package day5.demo2;

public class Mobile {
    String name;
    float price;

    public Mobile(String name,float price) {
        this.name = name;
        this.price = price;
    }

    public void tonghua(){
        System.out.println("打电话");
    }

}