Java基础(7)

面向对象特征

* 封装(encapsulation)
* 继承(inheritance)
* 多态(polymorphism)

封装

• 封装概述
  
  • 是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
• 封装好处
  
  • 隐藏实现细节，提供公共的访问方式
  • 提高了代码的复用性
  • 提高安全性。
• 封装原则
  
  • 将不需要对外提供的内容都隐藏起来。
  • 把属性隐藏，提供公共方法对其访问。
• private关键字特点
  
  • 是一个权限修饰符
  • 可以修饰成员变量和成员方法
  • 被其修饰的成员只能在本类中被访问
• 封装和private的应用：
  
  • 把成员变量用private修饰
  • 提供对应的getXxx()和setXxx()方法
  • private仅仅是封装的一种体现形式,不能说封装就是私有
• this关键字特点
  
  • 代表当前对象的引用
  • 用来区分成员变量和局部变量重名

示例

class Demo2_Phone {
    public static void main(String[] args) {
        Phone p1 = new Phone();
        p1.setBrand("三星");
        p1.setPrice(5288);

        System.out.println(p1.getBrand() + "..." + p1.getPrice());
        p1.call();
        p1.sendMessage();
        p1.playGame();
    }
}
/*
手机类
    属性:品牌brand,价格price
    行为:打电话call,发短信sendMessage,玩游戏,playGame
*/
class Phone {                               //java bean
    private String brand;                   //品牌
    private int price;                      //价格

    public void setBrand(String brand) {    //设置品牌
        this.brand = brand;
    }

    public String getBrand() {              //获取品牌
        return this.brand;      //this.可以省略,你不加系统会默认给你加
    }

    public void setPrice(int price) {       //设置价格
        this.price = price;
    }

    public int getPrice() {                 //获取价格
        return price;
    }

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

    public void sendMessage() {             //发短信
        System.out.println("发短信");
    }

    public void playGame() {                //玩游戏
        System.out.println("玩游戏");
    }
}

继承

让类与类之间产生关系,子父类关系

• 继承的好处
  
  • a:提高了代码的复用性
  • b:提高了代码的维护性
  • c:让类与类之间产生了关系，是多态的前提
• 继承的弊端
  
  • 类的耦合性增强了。
  • 注：
    
    • 开发的原则：高内聚，低耦合。
    • 耦合：类与类的关系
    • 内聚：就是自己完成某件事情的能力
• Java中类的继承特点
  
  • Java只支持单继承，不支持多继承。
    
    • 有些语言是支持多继承，格式：extends 类1,类2,…
  • Java支持多层继承(继承体系)
    
    • 如果想用这个体系的所有功能用最底层的类创建对象
    • 如果想看这个体系的共性功能,看最顶层的类
• 继承的注意事项
  
  • a:子类只能继承父类所有非私有的成员(成员方法和成员变量)
  • b:子类不能继承父类的构造方法，但是可以通过super(马上讲)关键字去访问父类构造方法。
  • c:不要为了部分功能而去继承
• this和super的区别
  
  • this:代表当前对象的引用,谁来调用我,我就代表谁
  • super:代表当前对象父类的引用

区别	this	super
调用成员变量	调用本类的成员变量,也可以调用父类的成员变量	调用父类的成员变量
调用构造方法	调用本类的构造方法	调用父类的构造方法
调用成员方法	调用本类的成员方法,也可以调用父类的方法	调用父类的成员方法

• 注意事项
  
  • super(…)或者this(….)必须出现在构造方法的第一条语句上

代码块

在Java中，使用{}括起来的代码被称为代码块。

• 代码块分类
  
  • 根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程)。
• 常见代码块的应用
  
  • a:局部代码块
    
    • 在方法中出现；限定变量生命周期，及早释放，提高内存利用率
  • b:构造代码块 (初始化块)
    
    • 在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
  • c:静态代码块
    
    • 在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。
    • 一般用于加载驱动

示例

//看程序写结果1
class Fu{
    public int num = 10;
    public Fu(){
        System.out.println("fu");
    }
}
class Zi extends Fu{
    public int num = 20;
    public Zi(){
        System.out.println("zi");
    }
    public void show(){
        int num = 30;
        System.out.println(num);
        System.out.println(this.num);
        System.out.println(super.num);
    }
}
class Test1_Extends {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
    }
}

//看程序写结果2
class Fu {
    static {
        System.out.println("静态代码块Fu");
    }

    {
        System.out.println("构造代码块Fu");
    }

    public Fu() {
        System.out.println("构造方法Fu");
    }
}

class Zi extends Fu {
    static {
        System.out.println("静态代码块Zi");
    }

    {
        System.out.println("构造代码块Zi");
    }

    public Zi() {
        System.out.println("构造方法Zi");
    }
}

• 重写:
  
  • 子父类出现了一模一样的方法(注意:返回值类型可以是子父类,这个我们学完面向对象讲)
  • 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。这样，即沿袭了父类的功能，又定义了子类特有的内容。
  • 方法重写注意事项
    
    • a:父类中私有方法不能被重写
      
      • 因为父类私有方法子类根本就无法继承
    • b:子类重写父类方法时，访问权限不能更低
      
      • 最好就一致
    • c:父类静态方法，子类也必须通过静态方法进行重写
      
      • 其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解(静态只能覆盖静态)
    • d:子类重写父类方法的时候，最好声明一模一样。
• final修饰特点
  
  • 修饰类，类不能被继承
  • 修饰变量，变量就变成了常量，只能被赋值一次
  • 修饰方法，方法不能被重写
  • 修改：
    
    • 基本类型，是值不能被改变
    • 引用类型，是地址值不能被改变,对象中的属性可以改变
  • 初始化
    
    • 显示初始化
    • 在对象构造完毕前即可
    • 以上两种方式不能同时使用

示例

class Demo6_Extends {
    public static void main(String[] args) {
        Son s1 = new Son();
        System.out.println(s1.getName() + "..." + s1.getAge());
        System.out.println("--------------------");
        Son s2 = new Son("张三",23);
        System.out.println(s2.getName() + "..." + s2.getAge());
    }
}
/*
* A:案例演示
    * 父类没有无参构造方法,子类怎么办?
    * super解决
    * this解决
* B:注意事项
    * super(…)或者this(….)必须出现在构造方法的第一条语句上
*/
class Father {
    private String name;            //姓名
    private int age;                //年龄

    public Father() {               //空参构造
        System.out.println("Father 空参构造");
    }

    public Father(String name,int age) {    //有参构造
        this.name = name;
        this.age = age;
        System.out.println("Father 有参构造");
    }

    public void setName(String name) {  //设置姓名
        this.name = name;
    }

    public String getName() {           //获取姓名
        return name;
    }

    public void setAge(int age) {       //设置年龄
        this.age = age;
    }

    public int getAge() {               //获取年龄
        return age;
    }
}

class Son extends Father {
    public Son() {                      //空参构造
        this("王五",25);              //本类中的构造方法
        //super("李四",24);               //调用父类中的构造方法

        System.out.println("Son 空参构造");
    }

    public Son(String name,int age) {   //有参构造
        super(name,age);
        System.out.println("Son 有参构造");
    }
}

多态

事物存在的多种状态

• 多态的前提
  
  • 要有继承关系
  • 要有方法重写
  • 要有父类引用子类对象
• 多态中的成员访问特点

内容	过程
成员变量	编译看左边（父类），运行看左边（父类）
（非静态）成员方法	编译看左边（父类），运行看右边（子类）
（静态）成员方法	编译看左边（父类），运行看左边（父类）

• 向上转型和向下转型
  
  • Father p = new Son();
  • Son s = (Son) p;
• 多态的好处
  
  • 提高代码的维护性（继承保证）
  • 提高代码的可扩展性（多态保证）
    
    • 可以当做形式参数，可以接收任意子类对象
• 多态的弊端
  
  • 不能使用子类的特有属性和行为