面向对象-3

1.this关键字：

this作用:

      this表示的是当前对象本身 更准确地说，this代表当前对象的一个引用。 普通方法中使用this。          区分类成员属性和方法的形参. 调用当前对象的其他方法（可以省略）

         位置：任意 用途：

1.构造方法，当构造方法中的参数名称跟类的成员变量名称一样的时候，可以使用this代表当前对象

注意：有了this之后，就可以将构造方法的参数跟成员变量保持一致（符合命名规范）

当构造方法中需要调用其他的构造方法时，可以使用this(参数列表)调用其他构造方法，但是必须位于方法体的一行(规则)

2.普通方法中： 当多个普通方法之间需要相互调用的时候，可以使用this来进行调用，指的是当前对象的其他方法

3.调用成员变量的时候如何使用： 当前方法中的参数名称跟成员变量保持一致的时候，使用this.变量名称 表示的是对象的值，而使用变量名称表示形参列表中的值 4.this不能用于static方法。

普通方法中使用this
        区分类成员属性和方法的形参
        调用当前对象的其他方法（可以省略）
        位置：任意

构造方法中使用this
        使用this来调用其他构造方法
        位置：必须是第一条语句

this不能用于static方法

public class TestThis {
    int a,b,c;
    TestThis(){
        System.out.println("正要new一个Hello对象");
    }
    TestThis(int a,int b){
    //    Hello(); 这样是无法调用构造方法的！
        this();//调用无参的构造方法，并且必须位于第一行
        a = a;//这里都是指的局部变量而不是成员变量
        this.a = a;//这样就区分了成员变量和局部变量 ， 这种情况占了this使用情况的大多数！
        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 tt = new TestThis(2,3);
        tt.chifan();
    }
}

2.static关键字：

静态属性的访问形式
        （1）对象名.属性
        （2）类名.属性
    静态方法
        访问修饰符static返回值类型 方法名（）｛｝
    访问形式
        （1）对象名.方法名（）；
        （2）类名.方法名（）；

修饰成员变量的时候，表示静态成员变量后者叫类变量
           普通变量在使用的时候，必须要通过对象名进行调用
           类变量或者静态变量可以使用对象名调用也可以使用类名进行调用
  修饰方法的时候，表示静态方法或者叫类方法
           普通方法在使用的时候，必须要通过对象名进行调用
           类方法或者静态方法可以使用类名，也可以使用对象名
   注意：
        1.静态变量，在创建对象之前被初始化，或者说在类被载入之前进行初始化
        2.静态变量被所有的对象共享，属于公共变量，对象和类都可以直接调用，但是推荐使用类调用
        3.成员变量放在堆中，而静态变量放在方法区中的静态区中
        4.静态变量不能定义在静态方法中
        5.静态方法可以在非静态方法中进行调用
        6.静态方法中不能直接调用非静态方法，换句话说可以间接调用非静态方法
        7.静态方法中不允许出现this调用
        8.一般工具类中的方法定义为static
  在类中，用static声明的成员变量为静态成员变量 ,或者叫做： 类属性，类变量.
       它为该类的公用变量，属于类，被该类的所有实例共享，在类被载入时被显式初始化，
  对于该类的所有对象来说，static成员变量只有一份。被该类的所有对象共享！！
       可以使用”对象.类属性”来调用。不过，一般都是用“类名.类属性”
       static变量置于方法区中！
    用static声明的方法为静态方法
       不需要对象，就可以调用(类名.方法名)
       在调用该方法时，不会将对象的引用传递给它，所以在static方法中不可访问非static的成员。
       静态方法不能以任何方式引用this和super关键字

public class TestStatic {
    int a;
    static int width;
    static void gg(){
    System.out.println("gg");
    }
    void tt(){
        System.out.println("tt");
    }
    public static void main(String[] args){
        TestStatic hi = new TestStatic();
        TestStatic.width = 2;
        TestStatic.gg(); //gg();
        hi.gg();//通过引用也可以访问static变量或static方法。不过，
// 一般还是使用类名.static成员名来访问。
        gg();
    } 
}

3.代码块：

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

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

public class TestStaticBlock {
    static {
        System.out.println("此处，可执行类的初始化工作！");
}
    public static void main(String[] args) {
        System.out.println("main方法中的第一句");
    } 
}

4.package：
    为什么使用package？
                为了了解类之间的重名问题
                为了便于管理类：合适的类位于合适的包！
    package怎么用？
                通常是类的第一句非注释性语句
                包名：域名倒着写即可，再加上模块名，并不内部管理类
    注意事项：
                写项目时都要加包，不要使用默认包
        com.gao和com.gao.car，这两个包没有包含关系，是两个完全独立的包。只是逻辑上看起来后者是前者的一部分JDK中的主要包
   Java.lang
        包含一些Java语言的核心类，如String,Math,lnteger,System和Thread，提供常用功能
    java.awt
        包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面（GUI）
    java.net
        包含执行不网络相关的操作的类
    java.io
        包含能提供多种输入/输出功能的类
    java.util

        包含一些实用工具类，如定义系统特性，使用不日期日历相关的函数

5.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);

6.封装：
    什么是封装
        面向对象三大特征之一 ——封装
    封装的概念
        封装：将类的某些信息隐藏在类内部，不允许外部程序直接访问，
        而是通过该类提供的方法来实现对隐藏信息的操作和访问
    封装的好处
        隐藏类的实现细节
        只能通过规定方法访问数据 
        方便加入控制语句
        方便修改实现

隐藏/封装(encapsulation)
    为什么需要封装？封装的作用和含义？
        我要看电视，只需要按一下开关和换台就可以了。有必要了解电视机内部的
    结构吗？有必要碰碰显像管吗？
        我要开车，….
    隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。
    我们程序设计要追求“高内聚，低耦合”。
    高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；
    低耦合 ：仅暴露少量的方法给外部使用

    封装的步骤
        1.修改属性的可见性-> 设为private
        2.创建公有的getter/setter方法-> 用于属性的读写
        3.在getter/setter方法中加入属性控制语句-> 对属性值的合法性进行判断

类图：

 定义类的时候需要包含以下组件：
                私有属性
                构造方法（无参构造方法和自定义构造方法）
                set/get方法
                普通方法

get变量名()方法，用于获取成员变量的值，方法用public修饰
set变量名(参数)方法，用于设置成员变量的值，方法用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 < 0) {
        this.health = 40;
        this代表 System.out.println("健康值应该在0和100之间，默认值是40");
    }else{
        this.health = health;
}
// 其它getter/setter方法
}

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