面向对象2

this关键字代表当前对象，使用this关键字引用 成员变量 和 成员方法

在一个类的方法或构造方法内部，可以使用“this.成员变量名”这样的格式来引用成员变量名，常常用来区分同名的成员变量和局部变量

public class Demo{ 
    private int a; 
    public Demo(int a){
        this.a = a; }
    public int getA(){
        return a; }
    public void setA(int a){
        this.a = a; } 
}

static被称为静态，可以用来修饰类的属性,方法,代码块,内部类。

static关键字的特点

1.随着类的加载而加载

public class TestDemo1 {
    public static void main(String[] args) {
        System.out.println(Demo1.b);
        
        new Demo1();
        new Demo1();
​
    }
}

public class Demo1 {
    static int b=10;
    int a=0;
    String s ="a";
    {
        System.out.println("这里是实例代码块1"+b);
    }
    {
        System.out.println("这里是实例代码块2");
    }
​
    static {
        System.out.println("这里是静态代码块1");
    }
    static {
        System.out.println("这里是静态代码块2");
    }
}

2.优先于对象

3.修饰的成员，被所有对象所共享

4.可不创建对象，直接被类调用

静态属性是类的所有对象共享的，即不管创建了多少个对象，静态属性在内存只有一个。

static方法可以使用对象调用，也可以直接用类名调用，建议类名直接调用。

在static方法内，只能访问类的static属性，不能访问类的非static属性。

public class bank {
​
     int name=10;
   // static int count;
    static int count=100;
​
    public  static void  show(){
        count--;
    }
​
    
    
    public void show3(){
        count--;
    }   //非static修饰的方法可以访问static修饰的属性
}

代码块在类中声明，类似一个没有名称的方法体（代码块），代码块分为 实例块 和 静态块。

实力块

每次创建对象时候调用

{
        //任何符合语法的java代码
}

静态块

类加载时候自动调用，仅一次，与对象的创建无关

static {
            //任何符合语法的java代码
}

概念：为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间

为什么要用包？

答：用以区别类的命名空间。包可以更好得管理逻辑相关的类，可以控制不同包之间的访问 权限

包的作用：

1. 避免类的重名

2. 按照不同功能管理类。

3. 访问控制权限。

   import 关键字 用来导入其他包的类

   java.lang比较特殊 自动加载

   包的命名规范

   第一级 项目性质

   第二级 项目公司名称

   第三级 项目名称

   第四级 项目功能名称

   第五级 下一级别的功能名称

java语言有四个权限访问修饰符，权限从大到小：

public : 公共权限 修饰类，属性，方法。可以被任意类访问。

protected: 受保护的权限 修饰属性，方法。

可以被同包类访问，如果不是同包类，必须是该类的子类才可以访问。

default : 同包权限 修饰 类，属性，方法 只能被同包的类访问

private : 私有权限 修饰属性，方法。只能在本类中访问。

package Day6;
​
public class Demo2 {
​
    public int punum;
    protected int prnum;
        int denum;
        private int prnum2;
​
   public void show(){
       System.out.println(punum);
       System.out.println(prnum);
       System.out.println(denum);
       System.out.println(prnum2);
   }
   
}
​

package Day6;
​
public class Demo3 {
    public static void main(String[] args) {
        Demo2 sc = new Demo2();
        System.out.println(sc.punum);
        System.out.println(sc.prnum);
        System.out.println(sc.denum);
        // private System.out.println(sc.prnum2);
    }
}

package java1;

import Day6.Demo2;

public class Demo4 extends Demo2 {
    public static void main(String[] args) {
        Demo4 sc1 = new Demo4();
        System.out.println(sc1.punum);
        System.out.println(sc1.prnum);
        //System.out.println(sc.denum);
        // private System.out.println(sc.prnum2);
    }
}

封装：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法 来实现对隐藏信息的操作和访问。

封装的好处：

1. 隐藏类的实现细节。

2. 只能通过规定方法访问。

3. 方便修改实现

4. 方便加入控制语句

public class Demo5 {
        private String name;
        public String  getName(){
                return name;
        }
        public void   setName(){
            this.name = name;
        }
}