08 构造方法

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

static 关键字 
在类中，用static声明的成员变量为静态成员变量 ,或者叫做： 类属性，类变量.
它为该类的公用变量，属于类，被该类的所有实例共享，在类被载入时被显式初始化，
对于该类的所有对象来说，static成员变量只有一份。被该类的所有对象共享！！
可以使用”对象.类属性”来调用。不过，一般都是用“类名.类属性”
static变量置于方法区中！

用static声明的方法为静态方法
不需要对象，就可以调用(类名.方法名)
在调用该方法时，不会将对象的引用传递给它，所以在static方法中不可访问非static的成员。
静态方法不能以任何方式引用this和super关键字

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

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

Import 
作用：如果不适用import，我们如果用到其他包的类时，只能这么写：java.util.Date，代码量太大，不利于编写和维护。通过import可以导入其他包下面的类，从而可以在本类中直接通过类名来调用。
用法：
import  java.util.Date; 
import  java.util.*;   //导入该包下所有的类。会降低编译速度，但不会降低运行速度。

注意要点：
java会默认导入java.lang包下所有的类，因此这些类我们可以直接使用。
如果导入两个同名的类，只能用包名+类名来显示调用相关类：
java.util.Date date  = new  java.util.Date();

import  static   
–import static java.lang.Math.*;//导入Math类的所有静态属性
–import static  java.lang.Math.PI;//导入Math类的PI属性
–然后，我们可以在程序中直接使用：System.out.println(PI);



方法调用中的参数传递（重中之重）
基本数据类型的参数传递：不能改变参数的值
引用数据类型的参数传递：不能改变参数的值
This修饰构造方法（必须是第一条语句）
This代表当前对象自身的引用（必须new）
This可以修饰属性，区别成员变量和局部变量
This修饰方法
This修饰构造方法（必须是第一条语句）
static
static变量：只有一份，属于类，可以类名. Static变量
static方法: 类名. Static方法，不能出现this和super
static代码块：只执行一次，最早执行的（类第一次调用）
package import
包：作用  
导入：import  com.bjsxt.oop.*;
静态导入： import static java.lang.Math.PI;

Static  单例模式

package 单例02;

public class GoodsInfo {
    public void showGoodsInfo() {
        System.out.println("商品详情");
        UserInfo info = UserInfo.getUserInfo();
        System.out.println(info.userName+info.psw);
    }
}
package 单例02;

import java.util.Scanner;

public class UserInfo {
    String userName;
    String psw;
    
    
    static UserInfo info;
    
    public static UserInfo getUserInfo() {
        if (info == null) {
            info = new UserInfo();
            Scanner input = new Scanner(System.in);
            System.out.println("请输入用户名");
            info.userName = input.next();
            System.out.println("请输入密码");
            info.psw = input.next();
        }
        return info;
    }
    
}
package 单例02;

public class Test {
    public static void main(String[] args) {
        UserInfo info = UserInfo.getUserInfo();
        
        GoodsList  list = new GoodsList();
        list.showGoodsList();
        
        
        GoodsInfo ginfo = new GoodsInfo();
        ginfo.showGoodsInfo();
    }
}
package 单例02;

public class GoodsList {
    public void showGoodsList() {
        System.out.println("商品列表");
        UserInfo info = UserInfo.getUserInfo();
        System.out.println(info.userName);
        System.out.println(info.psw);
    }
}



静态代码块 在类被加载时会使用。



构造方法
package 构造方法;

public class Dog {
    String name;
    int age;
    /**
     * 构造方法是创建对象的时候自动调用的方法
     * 构造方法的名字必须跟类名保持一致
     * 构造方法返回的类型是当前类的类型，但是在定义方法的时候无需声明返回值
     * 同时构造方法也不能return 
     * 
     * 当一个类中没有任何构造方法，系统会自动生成一个无参的构造方法
     * 如果类中声明了构造方法，则系统不会再生成无参构造方法
     * 
     * 构造方法也可以重载
     */
    public Dog(){
        name = "旺财";
        age = 2;
        System.out.println("无参构造");
    }
    
    public Dog(String name){
        name = "旺财";
        age = 2;
    }
    
    
    public Dog(String name,int age) {
        //this在构造方法中可以用来调用其他的构造方法  
        //必须出现在构造方法的第一行  
        this();
        this.name = name;
        this.age = age;
        
    }
    
}


package 构造方法;

public class Test {
    public static void main(String[] args) {
//        Dog wangcai = new Dog();
//        wangcai.name = "旺财";
//        wangcai.age = 10;
        
        
        Dog dahuang = new Dog("大黄", 10);
    }
}


this: 是一个关键字,代表当前对象的引用,就是那个对象执行到了这一行代码,那个对象就是当前对象
调用属性 : 当局部变量和成员变量重名的时候,使用this,解决重名问题,不重名可以省略
调用方法
调用构造方法
        this();
        this(“旺财”,100)
package thisDemo;
/**
 * this 是当前对象的引用
 * 哪个对象调用了当前方法 哪个对象就是当前对象
 * @author Administrator
 *
 */
public class Dog {
    String name;
    int age;
    
    public void test() {
        System.out.println(this);
        this.test();
        
    }
    public void test02() {
        System.out.println(this);
        this.test02();
        
    }
}


package thisDemo;

public class Test {
    public static void main(String[] args) {
        Dog wangcai = new Dog();
        System.out.println(wangcai);
        wangcai.test();
        
        Dog dahuang =new Dog();
        System.out.println(dahuang);
        dahuang.test();
    }

}


面向对象的三大基本特征：封装、继承、多态
程序设计追求的是：高内聚 低耦合
高内聚：就是类的内部数据操作细节自己完成，不允许外部干涉
低耦合：仅暴露少量的方法给外部使用


使用访问控制符，实现封装   
成员（成员变量或成员方法）访问权限共有四种：
public 公共的    
可以被项目中所有的类访问。(项目可见性)
protected 受保护的
可以被这个类本身访问；同一个包中的所有其他的类访问；被它的子类（同一个包以及不同包中的子类）访问
default／friendly 默认的/友好的（包可见性） 
被这个类本身访问；被同一个包中的类访问。
private 私有的    
只能被这个类本身访问。（类可见性）
类的访问权限只有两种
public 公共的
可被同一项目中所有的类访问。 (必须与文件名同名)
default／friendly 默认的/友好的
可被同一个包中的类访问。
 同一个类 同一个包中 子类 所有类
private *   
default * *  
protected * * * 
public * * * *
封装要点：
•类的属性的处理:
1.一般使用private.  (除非本属性确定会让子类继承)
2.提供相应的get/set方法来访问相关属性. 这些方法通常是public，从而提供对属性的读取操作。  （注意：boolean变量的get方法是用：is开头!）
•一些只用于本类的辅助性方法可以用private，
  希望其他类调用的方法用public