面向对象OOP2

本章概述 

一、this关键字

二、static关键字

三、代码块

四、package

五、import

六、封装

七、面向对象的三大特征

———————————————————————————————————————————一、this关键字

▪ this的作用:
– this表示的是当前对象本身，
– 更准确地说，this代表当前对象的一个引用。
▪ 普通方法中使用this。
– 区分类成员属性和方法的形参.
– 调用当前对象的其他方法（可以省略）
– 位置：任意
▪ 构造方法中使用this。
– 使用this来调用其它构造方法
– 位置：必须是第一条语句
▪ this不能用于static方法。

this:表示当前对象的指针
         指向当前对象，表示当前对象的引用
  用途：
        1、构造方法，当构造方法中的参数名称跟类的成员变量名称一样的时候，可以使用this代表当前对象
                  注意：有了this之后，就可以将构造方法的参数跟成员变量保持一致（符合命名规范）
                  当构造方法中需要调用其他的构造方法时，可以使用this(参数列表)调用其他构造方法，但是必须位于方法体的第一行（规则）
        2、普通方法中：
                  当多个普通方法之间需要相互调用的时候，可以使用this来进行调用，指的是当前对象的其他方法
        3、调用成员变量的时候如何使用：
                  当方法中的参数名称跟成员变量保持一致的时候，使用 this.变量名称 表示的是对象的值，而使用变量名称表示形参列表中的值
this测试代码

public class TestThis {
    int a;
    int b;
    int c;
    TestThis(){
        System.out.println("正要new一个hello对象");
    }
    TestThis(int a,int b){
        this();
        this.a = a;
        this.b = b;
    }
    TestThis(int a,int b,int c){
        this(a,b);
        this.c = c;
    }
    void sing(){

    }
    void chifan(){
        this.sing(); //sing();
        System.out.println("你妈妈喊你回家吃饭！");
    }
    public static void main(String[] args){
        TestThis hi = new TestThis(2,3);
        hi.chifan();
    }
}

二、static关键字

static:
        修饰成员变量的时候，表示静态成员变量或者叫类变量
             普通变量在使用的时候，必须要通过对象名进行调用
             类变量或者静态变量可以使用对象名调用也可以使用类名进行调用
        修饰方法的时候，表示静态方法或者叫类方法
             普通方法在使用的时候，必须要通过对象名进行调用
             类方法或者静态方法可以使用类名，也可以使用对象名
        注意：
            1、静态变量，在创建对象之前被初始化，或者说在类被载入之前进行初始化
            2、静态变量被所有的对象共享，属于公共变量，对象和类都可以直接调用，但是推荐使用类来调用
            3、成员变量放在堆中，而静态变量放在方法区中的静态区中
            4、静态变量不能定义在静态方法中
            5、静态方法可以在非静态方法中进行调用
            6、静态方法中不能直接调用非静态方法,换句话说可以间接调用非静态方法
            7、静态方法中不允许出现this调用
            8、一般工具类中的方法定义为static
static测试代码

public class TestStatic {
    int a;
    static int width;
    static void gege(){
        System.out.println("gege");
    }
    void tt(){
        System.out.println("tt");
    }

    public static void main(String[] args) {
        TestStatic ts = new TestStatic();
        TestStatic.width = 2;
        TestStatic.gege();
        ts.gege();
        gege();
    }
}

▪ 使用static声明的成员变量称为静态变量，
▪ 使用static声明的方法称为静态方法
▪ 静态变量不静态方法又称为类变量和类方法 

//使用static统计在类中一共产生了多少个对象
public class StaticDemo {    //声明类
    static int count;        //声明静态属性
    public StaticDemo(){     //无参构造方法
        count++;
        System.out.println("创建了" + count + "个对象");
    }

    public static void main(String[] args) {
        new StaticDemo();     //创建匿名对象
        new StaticDemo();     //创建匿名对象
        new StaticDemo();     //创建匿名对象
    }
}

 ▪ 静态属性的访问形式
– (1)对象名.属性
– (2)类名.属性
▪ 静态方法
– 访问修饰符 static 返回值类型 方法名(){}
▪ 访问形式
– (1)对象名.方法名();
– (2)类名.方法名();

小结 

 三、代码块

▪ 概念:使用”{}”括起来的一段代码
▪ 分类：根据位置可分类
▪ 普通代码块直接在方法或语句中定义的代码块
▪ 构造代码块直接写在类中的代码块
▪ 静态代码块使用static声明的代码块
▪ 同步代码块多线程的时候会学到

 静态初始化块

▪ 如果希望加载后，对整个类进行某些初始化操作，可以使用static初始化块。
▪ 类第一次被载入时先执行static代码块；类多次载入时，static代码块只执行一次；static经常用来进行static变量的初始化。
▪ 是在类初始化时执行，不是在创建对象时执行。
▪ 静态初始化块中不能访问非static成员。

四、package

1.package的作用

– 为了解决类之间的重名问题。
– 为了便于管理类：合适的类位于合适的包！

2.package的使用

– 通常是类的第一句非注释性语句。
– 包名：域名倒着写即可，再加上模块名，并不内部管理类。

3.注意事项：
▪ 写项目时都要加包，不要使用默认包。
▪ com.gao和com.gao.car，这两个包没有包含关系，是两个完全独立的包。只是
逡辑上看起来后者是前者的一部分。

JDK中的主要的包

1.java.lang
  包含一些Java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能。
2.java.awt
  包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。
3.java.net
  包含执行不网络相关的操作的类。
4.java.io
  包含能提供多种输入/输出功能的类。
5.java.util
  包含一些实用工具类，如定义系统特性、使用不日期日历相关的函数。

五、import

为什么需要import?
如果不适用import，我们如果用到其他包的类时，只能这么写：java.util.Date，代
码量太大，不利于编写和维护。通过import可以导入其他包下面的类，从而可以在
本类中直接通过类名来调用。
import怎么使用?
import java.util.Date;
import java.util.*; //导入该包下所有的类。会降低编译速度，但不会降低运行速度。
注意要点：
java会默认导入java.lang包下所有的类，因此这些类我们可以直接使用。
如果导入两个同名的类，只能用包名+类名来显示调用相关类：
java.util.Date date = new java.util.Date();

import static
▪ 静态导入的作用：用于导入指定类的静态属性
▪ JDK5.0后增加！
▪ 如何使用：
– import static java.lang.Math.*;//导入Math类的所有静态属性
– import static java.lang.Math.PI;//导入Math类的PI属性
– 然后，我们可以在程序中直接使用：System.out.println(PI);

六、封装

1.面向对象的三大特征之一 ------ 封装；
2.概念：
            将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
3.封装解决什么问题：
           如果任何一个处理类都可以直接对Dog进行赋值操作，那么当值不准确的时候，可以会产生意想不到的结果，
4. 如何在赋值的同时添加一些逻辑判断呢？
                封装可以解决此问题
5.作用：
            使用封装可以保证数据的规范，不符合规范的数据将无法进行操作

6.好处：
            ①③隐藏类的内部实现细节
            ②只能通过提供的方法进行访问，其他方法无法访问
            ③可以根据需求添加复杂的逻辑判断语句
            ④方便修改实现
7.面向对象的封装（狭义）可以用一句话概述： 为了保证数据安全和规范
            将类中的属性设置为私有属性，提供公有的外部方法供程序进行调用，可以实现丰富的细节操作
8.广义的封装：
           可以将完成特定功能的代码块封装成一个方法，供不同的程序进行调用

9.我们程序设计要追求“高内聚，低耦合”。
   高内聚：就是类的内部数据操作细节自己完成，不允许外部干涉；
   低耦合 ：仅暴露少量的方法给外部使用。

封装的步骤

 小结

public class Dog {
    private String name = "旺财";
    private int health = 100;
    private int love = 0;
    private String strain = "阿拉斯加";
    public int getHealth(){
        return health;
    }
    public void setHealth(int health ) {
        if (health > 100 || health < 40) {
            this.health = 40;
            System.out.println("正常值在0-100之间，默认值为：40");
        } else {
            this.health = health;
            System.out.println("健康值："+health);
        }
    }
    public String getName(){
        return name;
    }
    public void setName(String name){
        if(name.equals("")){
            this.name = "旺财";
            System.out.println("默认名字为：旺财");
        }else{
            this.name = name;
            System.out.println("名字："+name);
        }
    }
    public int getLove(){
        return love;
    }
    public void setLove(int love){
        if(love > 100|| love <60){
            this.love = 60;
            System.out.println("正常值为0-100，默认值为：60");
        }else{
            this.love = love;
            System.out.println("亲密值为："+love );
        }
    }
    public String getStrain(){
        return strain;
    }
    public void setStrain(String strain){
        if(strain.equals("")){
            this.strain = "阿拉斯加";
            System.out.println("默认值为：阿拉斯加");
        }else{
            this.strain = strain;
            System.out.println("品种为："+strain);
        }
    }

    public static void main(String[] args) {
        Dog dog =new Dog();
        dog.setName("旺财");
        dog.setHealth(90);
        dog.setLove(100);
        dog.setStrain("拉布拉多");
    }
}

 七、面向对象的三大特征

▪继承 inheritance
–子类 父类
–子类可以从父类继承属性和方法
–子类可以提供自己单独的属性和方法
▪封装/隐藏encapsulation
–对外隐藏某些属性和方法
–对外公开某些属性和方法
▪多态 polymorphism
–为了适应需求的多种变化，使代码变得更加通用！
▪面向过程只有封装性（功能的封装，而没有数据的封装），没有继承和多态