Java-this指针、Static关键字、代码块、Package、Import、面向对象的三大特征（继承 封装 多态）、访问控制符

this指针

/*
* this指针
* this:表示当前对象的指针
* – This代表当前对象自身的引用（必须new）
* – This可以修饰属性，区别成员变量和局部变量 
* – This修饰方法 
* – This修饰构造方法（必须是第一条语句）
* 
 * 用处：
 *       1、构造方法，当构造方法中的参数名称跟类的成员变量名称一样的时候，可以使用this代表当前对象
 *             注意：有了this之后，可以将构造方法的参数跟成员变量保持一致
 *             当构造方法中需要调用其他的构造方法时，可以使用this(name)调用其他构造方法，但是必须位于方法体的第一行
 *       2、普通方法中：
 *           当多个普通方法之间需要调用的时候，可以使用this来进行调用，指的是当前对象的其他方法
 *       3、成员变量的使用：
 *           当方法中的参数名称跟成员变量保持一致的时候，使用 this.变量名称 表示的是对象的值，而使用变量名称表示形参列表中的值
* */

public class ThisDemo {

    String name;
    int age;

/*    //用处一
    public ThisDemo(String name,int age){
        this.name = name;
        this.age = age;
    }*/

    //用处二
    public void test1(){
        System.out.println("test1");
    }
    public void test2(){
        System.out.println("test2");
        this.test1();  //这里有无this均可
    }

    //用处三
    public void test3(String name){
        System.out.println(name);
        System.out.println(this.name);
    }

    //用处四（需将用处一注释）：构造方法调用其他的构造方法
    public ThisDemo(String name){
        this.name = name;
    }
    public ThisDemo(String name,int age){
        this(name);     //就是这个地方调用其他的构造方法，并且这个this要放在第一行
        this.age = age;
    }

    public static void main(String[] args){
        ThisDemo td = new ThisDemo("hy",18);
        System.out.println(td.name+"\t"+td.age);
        System.out.println();

        td.test2();
        System.out.println();

        td.test3("Petrel");
    }
}

Static关键字

/* * static关键字
 *
 * 一般工具类中的方法定义为static，比如时间
 * – static变量：只有一份，属于类，可以类名. Static变量
 * – static方法: 类名. Static方法，不能出现this和super
 * – static代码块：只执行一次，最早执行的（类第一次调用）
 *
* static:
*       修饰成员变量的时候，表示静态成员变量或者叫类变量
*           普通变量在使用的时候，必须要通过对象名进行调用
*           类变量或者静态变量可以使用对象名调用也可以使用类名进行调用
*       修饰方法的时候，表示静态方法或者叫类方法
*           普通方法在使用的时候，必须要通过对象名进行调用
*           类方法或者静态方法可以使用类名，也可以使用对象名
*       注意：
*           1、静态变量，在创建对象之前被初始化，或者说在类被载入之前进行初始化
*           2、静态变量被所有的对象共享，属于公共变量，对象和类都可以直接调用，但是推荐使用类来调用
*           3、成员变量放在堆中，而静态变量放在方法去中静态区
*           4、静态变量不能定义在静态方法中
*           5、静态方法可以在非静态方法中进行调用
*           6、静态方法中不能直接调用非静态方法
*           7、静态方法中不允许出现this调用
*           8、一般工具类中的方法定义为static
 * 
 * 成员变量在堆中，static定义的类变量存放在方法区中的静态取。
 *
 * 类变量为该类的公用变量，属于类，被该类的所有实例共享。通过下面代码中的修改数据后所打印的结果可以看出
 *
 * 类变量被载入时被显示初始化，在创建对象之前被初始化
 * public class StaticDemo {
    String name = "hy";
    static int age = 10;

    public static void main(String[] args) {
           System.out.println(name);
        System.out.println(age);
        }
     }
 *  通过以上代码可得知输出name会报错，但输出age不会
 *
 * 静态变量不能定义在方法中，只能定义在方法外、类中
 *     public void test(){
        static int a = 10;
    }
 * 这样会报错
 *
 *1.定义方法可以用类名调用，也可以用方法名调用
 * 2.静态方法可以在非静态方法中进行调用。但是静态方法不可以直接调用非静态方法，只可以new一个：new StaticDemo.test2();
 * public class StaticDemo {
    String name = "hy";
    static int age = 10;

    public static void test(){
        System.out.println("可以被调用");
    }

    public void test2(){
        test();
    }

    public static void main(String[] args) {
        StaticDemo td = new StaticDemo();
        td.test(); //通过类名调用
        StaticDemo.test(); //通过方法名调用
        td.test2();
    }
 *
 * 在static方法中不可以访问非static的成员
 * 静态方法不能以任何方式引用this和super关键字，因为类变量在创建对象前就有了，而this表示当前对象的指针
 */

public class StaticDemo {
    String name = "hy";
    static int age = 10;

    public static void main(String[] args) {

        StaticDemo staticDemo = new StaticDemo();

        //使用对象进行调用
        System.out.println(staticDemo.name);
        System.out.println(staticDemo.age);

        //修改数据的时候，修改的是同一空间中的值
        staticDemo.age = 20;
        System.out.println(staticDemo.age);
        System.out.println(StaticDemo.age);

        StaticDemo.age = 30;
        System.out.println(staticDemo.age);
        System.out.println(StaticDemo.age);

        StaticDemo staticDemo1 = new StaticDemo();
        System.out.println(staticDemo.age);

        //使用类名调用
        //System.out.println(StaticDemo.name); 这里会报错，name归属于当前对象
        System.out.println(StaticDemo.age);//age加了static属于静态属性，归属于整个类对象

    }
}

代码块

/**代码块
* 使用{ }括起来的一段代码叫做代码块
 *
 * 分类：
 * *   普通代码块:定义在方法中，使用{}括起来的代码叫做普通代码块
 * *   构造代码块：定义在类中的使用{}括起来的代码叫做构造代码块
 * *           注意：每次代码运行的时候回将构造代码块中的代码添加到构造方法的前面
 * *                   构造代码块中的代码会添加到每一个构造方法中，当使用this(参数)的时候不会添加
 * *   静态代码块：使用static{}括起来的代码叫做静态代码块，在程序载入的时候优先执行
 * *           数据库连接等其他提前需要准备好的代码会放在static代码块
 * *   同步代码块：
 * *           在多线程的时候回使用，用来给共享空间进行加锁操作（后面讲）
 *
 * *   执行顺序：静态代码块--》构造代码块（创建对象的时候才会用到）--》普通代码块
 *
* */

/*
//普通代码块：按照顺序执行
public class CodeBlockDemo {

    public void test(){
        System.out.println("test");
        {
            System.out.println("我应该是什么分类");
        }
    }

    public static void main(String[] args) {
        CodeBlockDemo codeBlockDemo = new CodeBlockDemo();
        codeBlockDemo.test();
        {
            System.out.println("main");
        }
    }

}*/

/*
//构造代码块1
//每次代码运行的时候回将构造代码块中的代码添加到构造方法的前面
public class CodeBlockDemo {

    {
        System.out.println("构造代码块");
    }
/*根据反编译工具得：
    public CodeBlockDemo(){
        {
        System.out.println("构造代码块");
        }
    }
//默认会把System.out.println("构造代码块");这句话加到构造方法中，这样就成了一个构造代码块
 */

/*
    //此处代码作用：验证每次代码运行的时候回将构造代码块中的代码添加到构造方法的前面，会先运行出构造代码块
    public CodeBlockDemo(){
        System.out.println("构造方法");
    }


    public void test(){
        System.out.println("test");
        {
            System.out.println("我应该是什么分类");
        }
    }

    public static void main(String[] args) {
        CodeBlockDemo codeBlockDemo = new CodeBlockDemo();
        codeBlockDemo.test();
        {
            System.out.println("main");
        }
    }

}*/
/*
//构造代码块2
//构造代码块中的代码会添加到每一个构造方法中，当使用this(参数)的时候不会添加
public class CodeBlockDemo {

    int a ;
    int b ;

    public CodeBlockDemo(int a){
        this.a = a;
    }

    public CodeBlockDemo(int a,int b){
        this(a);//这样写的话System.out.println("构造代码块");只会加到public CodeBlockDemo(int a)和public CodeBlockDemo()中
        this.a = a;//这样写System.out.println("构造代码块"); 会加到public CodeBlockDemo(int a)和public CodeBlockDemo()还有public CodeBlockDemo(int a,int b){中
        this.b = b;
    }

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

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

    public static void main(String[] args) {
        CodeBlockDemo codeBlockDemo = new CodeBlockDemo();
    }
}*/

//静态代码块
    //先执行static{}中的先执行，用于数据库连接等其他提前需要准备好的代码
public class CodeBlockDemo {

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

    public static void main(String[] args) {
        CodeBlockDemo codeBlockDemo = new CodeBlockDemo();
    }
}

    /*
    int a ;
    int b;

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

    public CodeBlockDemo(){
        System.out.println("无参");
        System.out.println("构造方法");
    }

    public CodeBlockDemo(int a){
        this.a = a;
    }

    public CodeBlockDemo(int a,int b){
        this(a);
        this.b = b;
    }
    {
        System.out.println("构造代码块");
    }

    public void test(){
        System.out.println("test");
        {
            System.out.println("我应该是什么分类");
        }
    }

    public static void main(String[] args) {
        CodeBlockDemo codeBlockDemo = new CodeBlockDemo(1,2);
        codeBlockDemo.test();
        {
            System.out.println("main");
        }
    }
}*/

Package

/*
 * package:包，对应到文件系统就是多级目录
 *   为了解决两个问题：
 *       1、文件同名问题
 *       2、为了方便管理类，将具体处理功能的代码放到同一个目录下
 *   使用：
 *       一般定义package会放置在java文件的第一行
 *           package 域名的倒写
 *           package com.mashibing.
 *   完全限定名： 包名+类名
 *
 *   JDK中常用的包：
 *       lang：不需要手动导入，自动加载
 *       util:工具包
 *       net:网络包
 *       io:输入输出流包
 *
 * */

public class PackageDemo {
    public static void main(String[] args) {
        java.util.Date date = new java.util.Date();
    }
}

Import

package com.petrel;
import java.util.Date;
import static java.lang.Math.*;

    /*
     * import:
     *   当需要引入非lang包的其他java类的时候，需要使用import工具
     *       如果不使用import，每次在使用某个类的时候必须要将类的完全限定名都加上才可以使用，太过于繁琐
     *
     *   用法：
     *       import java.包名.类名；导入具体的类  推荐使用！
     *       import 包名.*;    将当前包下的所有类文件都进行导入 都导入的话，怕出现超多类文件的情况
     *   注意：
     *       当一个java文件中需要使用多个同名的类的时候，只能选择导入一个，另一个使用完全限定名的方式进行导入
     *
     *   静态导包：
     *       当需要使用某个类的多个方法的时候，同时又不想频繁写该类的名称，此时可以使用静态导包
     * */

    public class ImportDemo {

        //自己定义了一个sqrt方法
        //会优先使用当前类
        //    public void sqrt(){
//        System.out.println("sqrt");
//    }
        public static void main(String[] args) {
            //没导包可以这样写
            java.util.Date date = new java.util.Date();
            //导包了这样写
            Date date1 = new Date();

            System.out.println(Math.sqrt(2));
            System.out.println(Math.abs(-2));
            //静态导包实例 import static java.lang.Math.*;
            System.out.println(sqrt(2));
            System.out.println(abs(-2));
        }
}

面向对象的三大特征

继承 inheritance
–子类 父类
–子类可以从父类继承属性和方法
–子类可以提供自己单独的属性和方法

封装/隐藏encapsulation
–对外隐藏某些属性和方法
–对外公开某些属性和方法

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;
            System.out.println("健康值应该在0和100之间，默认值是40");
    } else
        this.health  =  health;
    }
    // 其它getter/setter方法
}

/*
 *封装：
 * （狭义）将类中的属性设置为私有属性，提供共有的外部方法供程序进行调用，可以实现丰富的细节操作
 * （广义）可以将完成特定功能的代码块封装成一个方法，供不同的程序进行调用
 * 目的：为了保证数据安全和规范
 *
 * 隐藏内部的复杂性，对外公开简单的接口
 *
 * *   定义类的时候需要包含以下组件：
 *       私有属性
 *       构造方法（无参构造方法和自定义构造方法）
 *       set/get方法
 *       普通方法
 *
 * 高内聚，低耦合
 * 同一个事情聚合到一起，事情相互独立的每个程序之间不掺和在一起
 */
package com.petrel;

public class Dog {

    private String name;
    private int age;
    private String color;

    public Dog() {

    }

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

    public void setAge(int age) {
        if (age > 0) {
            this.age = age;
        } else {
            System.out.println("输入年龄不规范，重新输入");
        }
    }

    //不写这里 外部不能调用私有属性
    public int getAge(){
        return this.age;
    }

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

    public String getName() {
        return name;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getColor() {
        return color;
    }

    public void eat() {
        System.out.println("吃骨头");
    }

    public void paly() {
        System.out.println("玩");
    }

    public void show() {
        System.out.println("名字：" + name);
        System.out.println("年龄：" + age + "岁");
        System.out.println("颜色：" + color);
    }
}
------------
package com.petrel;

/*
 * 封装：
 *       概念：
 *           将类的某些信息隐藏在类内部，不允许外部程序直接访问，
 *           而是通过该类提供的方法来实现对隐藏信息的操作和访问
 *       封装解决什么问题：
 *          如果任何一个处理类都可以直接对Dog进行赋值操作，那么当值不准确的时候，可以回产生额外的结果，
 *           如何在赋值的同时添加一些逻辑判断呢？
 *               封装可以解决此问题
 *       作用：
 *           使用封装可以保证数据的规范，不符合规范的数据将无法进行操作
 *       好处：
 *           1、隐藏类的内部实现细节
 *           2、只能通过提供的方法进行访问，其他方法无法访问
 *           3、可以根据需求添加复杂的逻辑判断语句
 *           4、方便修改实现
 *       面向对象的封装（狭义）可以用一句话概述： 为了保证数据安全和规范
 *           将类中的属性设置为私有属性，提供共有的外部方法供程序进行调用，可以实现丰富的细节操作
 *       广义的封装：
 *           可以将完成特定功能的代码块封装成一个方法，供不同的程序进行调用
 * */

public class DogTest {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.setName("皮皮");
        dog.setAge(20);
        dog.setColor("白色");
        dog.show();

    }
}

多态 polymorphism
–为了适应需求的多种变化，使代码变得更加通用！
面向过程只有封装性（功能的封装，而没有数据的封装），没有继承和多态

访问控制符

package com.petrel;

public class AccessControlDemo {

    //protected 当前包下和子类下可以访问
    protected String str = "test";

    //类的访问修饰符只有两个 public 和default
    public String getStr() {
        return str;
    }
    class Test{

    }

    //构造方法可以有protected 和 private
    public AccessControlDemo(){

    }
    private AccessControlDemo(int a){

    }
    protected AccessControlDemo(String b){

    }
}
------------
package com.petrel;

public class Test {
    public static void main(String[] args) {
        AccessControlDemo a = new AccessControlDemo();
        System.out.println(a.str);
    }
}