java入门（面向对象）

java入门（面向对象）

this关键字

this 关键字
代表当前对象(当前new的对象),存储对象的地址

​ 1.能够在构造器的首行用来调用本类中的其他构造器
​ this(参数列表);

​ 2.用来区分成员与局部同名问题
​ 如果出现同名问题,默认就近原则
​ 如果出现同名问题,想要指代调用同名的成员,需要 this.成员 调用
​ 不存在同名问题,指代成员的时候,this.可以省略

​ this在构造器中默认指代当前new的对象
​ this在成员方法中,默认指代当前调用成员方法的对象

​ 注意:
​ 构造器之间不能相互调用
​ 在静态的被static修饰的方法中不能使用this

代码展示

package com.xxx.lemon;

public class Classoo1_This {
    public static void main(String[] args) {
        Cat cat=new Cat("庞坤","坤哥");
        cat.info();
        Cat cat2=new Cat("林儒文","棉花糖","白色");
        cat2.info();
    }
}
class Cat{
    public String name;
    public String type;
    public String color;

public Cat(){
    System.out.println("这是一个空构造");
}
public Cat(String name){
    this.name=name;
}
public Cat(String name,String type) {
    this.name = name;
    this.type=type;
}
public Cat(String name, String type, String color) {
    this(name, type);
    this.color=color;

}
public void info(){
    String name="张成茂";//注意就近原则
    System.out.println(this.name+"..."+type);
}

static关键字

static 关键字
静态的
static是成员修饰符,只能修饰成员,不能修饰局部
成员位置: 类中方法外
成员内容: 定义在类中方法外
成员变量 :
不被static修饰的变量 -->实例变量
被static修饰的 --> 静态变量|类变量
成员方法
不被static修饰的成员方法 --> 成员方法|实例方法
被static修饰的方法 -->静态方法|类方法
无论是否被static关键字修饰都定义在成员位置,都是成员

​ 修饰变量 : 静态变量|类变量
​ 修饰方法 : 静态方法|类方法

​ 使用:
​ 1.通过对象使用,通过对象的引用调用
​ 引用.静态变量名
​ 引用.静态方法名(参数列表);

​ 2.通过类名调用
​ 类名.静态变量名
​ 类名.静态方法名(参数列表)

​ 修饰块
​ 修饰类

​ 静态的是属于类的
​ 成员是属于对象的

​ 静态内容是独一份的,在类第一次加载完成之后就进行初始化,只初始化一次
​ 静态变量在静态区中(方法区中),所有对象共享的唯一的静态内容
​ 加载内容是先静态后成员

代码展示

package com.xxx.lemon;

public class Class002_Static {
   static int i=100;
    int j=1;

    public static void main(String[] args) {
        //局部变量
        boolean b=true;
        System.out.println(i);

    Class002_Static cs=new Class002_Static();
      cs.j=100;
        System.out.println(cs.j);
        System.out.println(i);
        System.out.println(cs.i);

        //Class002_Static Class002_Static_Test=new Class002_Static();
        Test();
        Class002_Static.Test();
        cs.Test();

}    //创建对象
         //本类中可以省略类名


    //静态方法
    public  static void Test(){
        System.out.println("静态方法");
    }

}

注意:
静态内容是独一份的

​ 静态内容中只能直接使用静态的内容,不能直接使用成员内容,需要通过对象使用成员
​ 成员的内容中可以直接使用成员内容,可以直接使用静态内容

​ 成员方法中this默认指代当前调用成员方法的对象
​ 静态方法中不能使用this,因为静态方法可以通过类名调用,在调用时可以存在对象,所以不允许使用

block块

block块
{} 自成作用域
定义位置 执行时机
{} 定义在方法中或者语句块中 --> 局部代码块|普通语句块 所在方法调用时候
{} 定义在类中方法外 -->构造块 创建对象的时候
static {} 定义在类中方法外 --> 静态块 类加载

​ 构造块中的代码在编译期间会被编译到要执行的构造器代码上面,所以构造块代码在构造器代码之前执行
​ 如果存在多个构造块,从上到下依次执行
​ 在类第一次加载完成之后,就执行,并且只执行一次
​ 如果存在多个静态块,从上到下依次执行

​ 执行顺序: 静态块–>main–>创建对象了–>构造块–>构造器

​ 作用:
​ 静态块: 一般作为一些数据的加载,配置…在类加载完成之后就执行,并且只执行一次,后续不能调用,不需要调用
​ 可以为静态内容做初始化操作
​ 构造块: 一般也是为对象的成员初始化
​ 局部代码块:
​ 自成作用域
​ 具有语义化特点

package com.xxx.lemon;

public class Demo3_block {
    static int i = 18;

    public Demo3_block(){
        System.out.println("构造器");
    }

    //静态块
    static{
        System.out.println("静态块1");
    }
    static{
        System.out.println("静态块2");
    }
    static{
        System.out.println("静态块3");
    }

    //构造块
    {
        System.out.println("构造块1");
    }
    {
        System.out.println("构造块2");
    }
    {
        System.out.println("构造块3");
    }


    public static void main(String[] args) {
        System.out.println("----------------------");
        //局部
        //局部变量
        int i = 5;

        System.out.println(i);

        //局部代码块
        {
            i = 10;
            System.out.println(i);
        }
        System.out.println(i);

        new Demo3_block();

    }
}

执行顺序

找到打印顺序+结果
静态变量–>静态块->主方法–>new–>对应的构造器(空构造)–>构造块->构造器

​ 构造块的代码会被编译到要执行的构造器代码的上面

public class Class002_BlockTest {
public static int a = 0;

static {
	a = 6;
	System.out.println("1、静态代码块执行a=" + a); //6
}
public Class002_BlockTest() {
	this(a); //6
	System.out.println("6、"+a);  //10
	System.out.println("7、无参构造方法执行a=" + a); //10
}
public Class002_BlockTest(int n) { //n=6
	{
		a = 10;
		System.out.println("3、非静态代码块执行a=" + a); //10
	}
	System.out.println("4、"+n); //6
	System.out.println("5、"+a);//10
}	
public static void main(String[] args) {
	System.out.println("2、main"); // main
	Class002_BlockTest tsc = new Class002_BlockTest();
}

}

Debug调用工具

Debug 调试工具 ****
作用:
1.追踪程序的执行流程
2.定位异常的位置
3.查看程序执行过程中变量的变化情况
4.根据程序的执行过程学习第三方框架的源码

​ 使用;
​ 1.设置断点 (当程序执行到断点所在位置,会进入到debug调试窗口,后面的每一行语句的执行由程序猿控制)
​ 在行号的后面点击一下设置断点,点一下取消断点
2.debug模式下运行
step over F8 下一步跳过 下一步有方法的调用也不进入,不跟随执行,直接执行下一行
step in F7 步入 下一步 下一步如果是自定义方法的调用,进入跟随执行,jdk提供的类库中的方法的调用,不进入
Force step in alt+shift+F7 强制步入 下一步 下一步如果是自jdk提供的类库中的方法的调用,强制进入跟随执行
step out 下一步调出方法的调用,直接结束调用执行进入下一步
Run to cursor 跳到光标所在位置继续执行

private

数据不安全情况:
年龄出现负值…直接操作成员变量,直接赋值,只要符合类型的要求,就能够成功赋值

解决隐患: 在其他类中,不允许直接访问一个类中的成员

private关键字 私有的
成员修饰符,只能修饰成员不能修饰局部的
一个成员一旦私有,只能在本类中使用,外部类无法使用

私有的成员需要配合公共的访问方式一起使用–>方法
设置器 setter
访问器 getter

私有的属性配合公共的访问方式就能够实现安全么??
1.不能直接访问操作成员 2.设置器或者访问器中,方法中可以进行逻辑的判断等…

注意:
定义的模板类中的属性都要私有化,并提供一对公共的访问方式

数据不安全情况:
年龄出现负值…直接操作成员变量,直接赋值,只要符合类型的要求,就能够成功赋值

解决隐患: 在其他类中,不允许直接访问一个类中的成员

private关键字 私有的
成员修饰符,只能修饰成员不能修饰局部的
一个成员一旦私有,只能在本类中使用,外部类无法使用

私有的成员需要配合公共的访问方式一起使用–>方法
设置器 setter
访问器 getter

私有的属性配合公共的访问方式就能够实现安全么??
1.不能直接访问操作成员 2.设置器或者访问器中,方法中可以进行逻辑的判断等…

注意:
定义的模板类中的属性都要私有化,并提供一对公共的访问方式

包的机制

包机制: -->文件夹
目的: 便于管理项目中众多的类,提供多种命名空间

​ 包信息在类中的首行显示
​ pakage --> import --> 类的定义

不需要导包的类:
1.java.lang包下的内容
2.同包下的类

导包: 指明要使用的类的位置
1.使用的位置直接指明类的权限定名(包名.类名),但是只有当前这一次有效
2.使用import进行导包,当前类中都可以进行使用
import 包名.类名;
定义在类的上面
3.模糊匹配导入
import 包名.*;
模糊匹配某一个包下的所有类
会江都编译效率,不会降低运行效率

​ 4.静态导入:只能导入静态内容
​ import static

注意:
先建立包再建类
定义包名的规则: 公司域名倒着写+功能名字|模块名字