JAVA面向对象2

JAVA面向对象2

一，this关键字

代表当前对象(当前new的对象),存储对象的地址

1.1 能够在构造器的首行用来调用本类中的其他构造器

class Phone{
    //创建手机类
    public String name;
    public String color;
    public int price;

    public Phone(String name,String color){
        this.name = name;
        this.color = color;
    }
	//this(参数列表)出现在构造器首行，则用来调用其他构造器
    public Phone(String name,String color,int price){
        this(name,color);//调用了上面的Phone(String name,String color)构造器
        this.price = price;
    }
}

1.2 用来区分成员与局部同名问题

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

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

class Phone{
    //创建手机类
    public String name;
    public String color;
    public int price;

    public Phone(String name,String color){
        this.name = name;//区分了成员变量与局部变量同名的问题
        this.color = color;
    }
	//this(参数列表)出现在构造器首行，则用来调用其他构造器
    public Phone(String name,String color,int price){
        this(name,color);//调用了上面的Phone(String name,String color)构造器
        this.price = price;
    }
}

注意:

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

二，static关键字

static属性: 属性被所有对象共享； 这个属性先于对象存在的

static 方法：这个方法先于对象存在

static是成员修饰符,只能修饰成员,不能修饰局部

• 成员位置: 类中方法外

• 成员内容: 定义在类中方法外

• 成员变量 :

  ​ 不被static修饰的变量 -->实例变量
  ​ 被static修饰的 --> 静态变量|类变量

• 成员方法

  ​ 不被static修饰的成员方法 --> 成员方法|实例方法
  ​ 被static修饰的方法 -->静态方法|类方法

  无论是否被static关键字修饰都定义在成员位置,都是成员

2.1 static的调用方法使用

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

public class Static01 {
    //定义一个静态变量并赋值
    public static int j = 20;

    public static void main(String[] args) {
        //创建对象
        Static01 sta  = new Static01();
        System.out.println(sta.j);//通过引用的方式调用静态对象
    }
}

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

public class Static02 {
    //定义一个静态变量并赋值
    public static int j = 20;

    public static void main(String[] args) {
        //创建对象
        Static02 sta  = new Static02();
        System.out.println(Static02.j);//通过类名的方式调用静态对象
    }
}

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

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

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

三，block块

用一对{}表示块区间

（经常用来初始化类，加载类信息时执行！）

定义在方法中或者语句块中 --> 局部代码块|普通语句块
定义在类中方法外 -->构造块
static {} 定义在类中方法外 --> 静态块

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

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

public class Block01 {
    static int i = 10;

    public Block01(){//在使用构造器之前，先执行构造块，再执行构造器里的内容
        System.out.println("构造器");
    }

    //静态块
    static{
        System.out.println("静态块1");//程序优先执行静态块
    }

    //构造块
    {
        System.out.println("构造块1");//在使用构造器前执行
    }


    public static void main(String[] args) {
        System.out.println("---------main-------------");

        System.out.println(i);

        //局部代码块
        {
            int i = 10;//局部代码块中的变量只能作用在局部代码块中
            System.out.println(i);
        }
        System.out.println(i);

        new Block01();//调用构造器

    }
}

如果希望加载后，对整个类进行某些初始化操作，可以使用static初始化块。

• 是在类初始化时执行，不是在创建对象时执行。
• 静态初始化块中不能访问非static成员。

作用:

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

四，package包

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

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

不需要导包的类:

​ 1.java.lang包下的内容
​ 2.同包下的类

导包: 指明要使用的类的位置

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

//导入需要使用的包
import java.util.Scanner;
import java.util.Random;
import static java.lang.Math.PI;
import static java.lang.Math.random;

//当需要用的工具类过多，可使用模糊匹配导入
import java.util.*;
import static java.lang.Math.*;

五，encapsulation封装

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

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

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

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

​ 设置器 setter
​ 访问器 getter

class Person{
private String name;
private int age;

class Person{
    private String name;
    private int age;
    public Person(){

    }

    //设置私有的age属性设置器
    public void setAge(int age){
        if(age<0 || age>150){
            System.out.println("年龄不合法..");
            this.age = 18;  //默认值
            return;
        }
        this.age = age;
    }

    //获取私有属性age属性值的访问器
    public int getAge(){
        return this.age;
    }
}

私有的属性配合公共的访问方式就能够实现安全么??

1. 不能直接访问操作成员
2. 设置器或者访问器中,方法中可以进行逻辑的判断等…

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