类和对象及代码块

目录

一.封装

四种访问修饰符

public :共有的，公开的

private：私有的

构造方法：产生对象

this关键字：

 代码块;是用{}括起来的代码块

1.基本代码块

2.成员代码块（构造快）：

3.静态代码块：

匿名对象：new Bank();

---

一.封装

封装具有保护性和易用性。（封装有很多种表现形式）

private实现属性和方法的封装只是其中的一种表现形式。比如内部类也是封装的一种。

四种访问修饰符

private(类访问权限) -> default（包访问权限）—> protect（继承访问权限）—> public

public :共有的，公开的

被public修饰的，在当前项目中随处可见

private：私有的

被private修饰的只在当前类中可见，类的外部就不知道他的存在了

通过getter 和setter访问private修饰的属性。

那些属性可以可见，哪些可以修改，根据具体情况而定。

public class TestPrivate {
    public static void main(String[] args) {
        Bank bank = new Bank();
        double balance = bank.getBalance();
        int id = bank.getId();
        bank.setBalance(1123);
        bank.setId(123);
        
    }
}
class Bank{
    private int id;
    private double balance;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
}

private可以只能修饰内部类。

构造方法：产生对象

1.使用new关键字在堆中分配空间。

2.调用构造方法为对象成员变量赋值；

构造规则：

1.方法名与类名称完全相同

2.没有返回值

3.类中之上存在一个构造方法，如果不写，默认为空参构造方法 

public class TestPrivate {
    public static void main(String[] args) {
        Bank bank = new Bank();
        Bank bank1 = new Bank(121);
        Bank bank2 = new Bank(123,123);

    }

}
class Bank{
    private int id;
    private double balance;

    public Bank() {
    }

    public Bank(int id) {
        this();
        this.id = id;
    }

    public Bank(int id, double balance) {
        this(id);
        this.balance = balance;
    }
}

this关键字：

 代码块;是用{}括起来的代码块

分类：

1.基本代码块

，定义在方法中，方法的每次调用都会执行，并且代码块内部的属性作用和可见范围就只在代码块内部

2.成员代码块（构造快）：

定义在类中的代码块。优先于构造方法执行。有几个对象产生就调用几次代码块。

3.静态代码块：

被static修饰的定义在类内部的被{}括起来的代码块，只在类加载时执行一次。

匿名对象：new Bank();

没有给创建的对象指出引用，所以后期无法调用，被叫做匿名对象，常用于测试

类

内部类：内部类就相当于普通类中得普通属性属性。

举例：心脏和身体：身体可以看作一个普通类，心脏就相当于一个内部类。

使用内部类得原因：

采用封装得思想，保护性内部类得属性和方法和对象，易用性。

1，内部类和外部类可以方便的访问彼此的私有域；

2，内部类就可以对外部类的外部完全隐藏（将内部类当作外部类的一个属性来修饰），内部类的修饰符可以是private -> deault -> protected -> public ，只有内部类可以使用private来修饰。

3，内部类可以变相实现多继承。（不推荐）

 内部类也可以继承类，当内部类与外部类都继承类不同的类，外部继承的东西，内部可以使用，内部类继承的，外部类也可以使用，就变相的实现了内部类的多继承。

 

内部类得种类：

1，成员内部类：在外部类的内部不适用static关键字修饰的类（类比成员方法）

内部类就类比成员方法，成员方法肯定无法拥有静态域。

成员内部类与成员类的访问关系：

1），内部类可以调用外部类的对象，因为在内部类会将外部的对象传入到改内部类

 

 

 2），成员内部类可以访问外部类，而成员类却无法访问内部类的原因在于，要想有内部类的对象，必须先有成员类的对象，  成员内部类创建对象   依赖于   成员类的对象。

1），成员内部类可以访问成员类的所有属性和方法，无论是否是private修饰的（将成员内部类看作为一个属性，那么这个属性在该成员类的内部，还在该成员类的内部，所以可见。）

2），成员类对成员内部类的方法和属性无法访问，必须通过创建改内部类的对象，才可以访问。（相比一个教室里面的学生，教室相当于成员类，学生相当于成员内部类，学生可以对教室的黑板桌子进行访问，而教室无法知道学生的姓名和性别，如果要访问，需要有一个确切的学生对象，才可以访问）。

 

 创建内部类对象的方式：

1），在成员类的内部（在Outer类中创建Inner对象）

2），在成员类的外部类（在Test类中创建Inner对象）

成员内部类中可以访问外部类的静态域，但是成员内部类中不可以定义静态域。（成员内部类相当于一个成员属性，成员属性是不存在静态域的）（成员内部类需要外部对象才能创建，如果定义了static，static修饰的东西，不需要对象可以访问，而这一点和内部类矛盾，所以不能有静态域）。

 

2，静态内部类：使用static修饰的内部类（类比两个类，但是却又有包含的关系）

静态内部类就相当于一个普通类却被套在了一个类的内部

静态内部类不需要外部类的对象，因为静态内部类相当于外部类的静态属性。

静态内部类不依赖外部类的对象，因此无法访问外部类的成员方法，但是可以访问外部类的静态方法。

静态内部类属于外部类的属性，所以静态内部类中的静态域，无论权限都可以被外部类通过类名.方法名获取，内部类访问外部类的静态域也是如此。

外部类访问内部类的成员属性，只能通过创建内部类的对象，内部类访问外部类也是如此。

 

3，匿名内部类（Lambda表达式的前身）（定义在方法中，类比形参）

定义在方法中，一般是方法的形参或者实参，没有任何权限修饰符。

匿名内部类也是方法中的一种，只不过这个类定义在方法的参数列表中，

同样，如果匿名内部类读取了方法的局部变量或者方法的形参，也不可以修改

 

 

 

4，方法内部类（定义在方法中，类比局部变量）

1，方法内部类的生命周期只是在该方法被调用的时候，并且该内部类不能使用任何修饰符来修饰，也不可以是静态的。

2，对外部类的外部完全隐藏

3，该类类比成员变量，因此所有的静态域也不能存在。

4，方法内部类对外部方法的 形参，局部变量 一旦进行了读取，那么该形参和局部变量就无法修改，无论实在内部类还是方法中，都不可以修改。只要在方法内部类中引用的变量，就不可以修改。