面向对象2

this关键字

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被称为静态，可以用来修饰类的属性,方法,代码块,内部类。

static关键字的特点

1.随着类的加载而加载

public class TestDemo1 {
    public static void main(String[] args) {
        System.out.println(Demo1.b);
        /*
        运行结果：这里是静态代码块1
                这里是静态代码块2
                10
                这里是实例代码块110
                这里是实例代码块2
                这里是实例代码块110
                这里是实例代码块2
​
                注意：static修饰的代码块永远比实例化代码块的优先级高，而同级别的运行顺序则由代码块的先后顺序确定。
                为什么还是先输出的是 Demo1中的静态代码块？
                在main方法中执行输出Demo1.b时，已经发生了将Demo1类从硬盘加载到内存的动作，由于是第一次加载，所以先运行了静态代码块然后通过print输出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方法内，只能访问类的static属性，不能访问类的非static属性。

public class bank {
​
     int name=10;
   // static int count;
    static int count=100;
​
    public  static void  show(){
        count--;
    }
​
    /*public static void show1(){
        name--;
    }
     */
    /*
    error 被static修饰的方法不能访问非static修饰的属性。
     */
    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);
   }
   /*
   public       公共的         任何一处
   protected    受保护的       本类，本包不同类，不同包的子类
   （空）                      本类，本类不同包
   private      私有的         本类
​
    */
}
​

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;
        }
}