面向对象2

一，this关键字

1.this关键字代表当前正在被操作的对象

   使用this关键字明确告诉程序，调用的是当前对象中的成员变量

   这样就可以在方法中区分成员变量和局部变量

2.this关键字调用当前当前对象中的成员方法

3.使用this关键字，在一个构造方法中调用另一个构造方法

package Day4;

public class Cat {
    String name;
    int age;
    public  Cat(){
        this("jh",20);
    }
    //在Cat（）构造方法中使用this调用另一个含参构造方法
    public Cat(String name,int age){
        this.name = name;
        this.age = age;
    }
    //在含参构造方法中使用this调用当前成员变量
    public void eat(){
        this.drink();
        System.out.println(name+"吃东西");
    }
    //使用this调用成员方法
    public void drink(){
        System.out.println(name+"喝东西");
    }
    public void showinfo(){
        System.out.println("姓名："+this.name);
        System.out.println("年龄："+this.age);
    }
}

二.static关键字

static： 被称为静态，可以用来修饰成员变量，成员方法，代码块，内部类

static修饰的成员在内存中只有一份（与类一样，只有一份）

特点：随着类的加载而加载，只要类被加载，静态成员就可以使用

          优先于对象存在

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

          可不创建对象，直接使用类名调用

使用static修饰的成员方法就是静态方法

注：静态方法中只能调用静态成员

       非静态方法中可以调用静态成员

package Day4.StaticDemo;

public class Student {
    String name;
    long num;
    static String spe = "人工智能";
    int grade;

    public static void showSpe(){
        System.out.println("专业："+spe);
       /* System.out.println(this.num);
        因为调用的num并不是静态变量所以此处会出错
       */

    }
    public void showinfo(){
        System.out.println("姓名："+name);
        System.out.println("学号："+num);
        Student.showSpe();
        /*
        此处非静态成员可以调用静态成员
        
         */
    }
}

三，代码块

定义：没有名称的方法

分类

1.实例代码块：

没有使用static修饰的，每次创建对象时被自动调用一次

2.静态代码块：

使用static修饰的，在类首次被加载时被调用执行，只执行一次，后续调用类时不会执行

注：静态代码块优先于实例代码块执行

package Day4.Code;

public class Demo {
    static int a = 5;
    {
        System.out.println("实例代码块1");
    }
    {
        System.out.println("实例代码块2");
    }
    static {
        System.out.println("静态代码块1");
    }
    static {
        System.out.println("静态代码块2");
    }
}

package Day4.Code;

public class Test {

    public static void main(String[] args) {
        new Demo();
        //没次类的加载都会先运行静态代码块，在运行实例代码块，最后再运行本身的程序
        //静态代码块只会在第一次类的加载时进行执行
        //实例代码块每次生成对象时都会执行一遍
        System.out.println(Demo.a);
        Demo.a =5;

        Demo.a = 6;
        System.out.println(Demo.a);

        new Demo();
    }
}

四，包（package）

包：用来管理类的

具体体现：

按照功能模块管理类

把同一功能的类放在一个包中

控制访问权限

避免重名类

包的命名规则：一般使用小写，用.区分包的级别

关键词：import

import：使用import关键字导入其他包中的类

eg：java.util.scanner--->全类名=包名（地址）+类名（类的简称）

注：java.lang包中的类比较特殊，使用时不需要导入

五，访问权限修饰符

1，public：公共权限

可以在项目中的任何位置都可以访问到

可以修饰类，成员变量，成员方法，内部类

2，protected：受保护权限

可以在本类，同包中的其他类，不同包的子类中访问到

可以修饰成员变量，成员方法，内部类

3，（空）/（default）：默认权限

可以在本类，同包中的其他类中访问到

可以修饰类，成员变量，成员方法，内部类

4，private：私有权限

只能在本类中访问到

可以修饰成员变量，成员方法，内部类

注：在本类中所有权限都可以被访问到

六，封装

理解封装一词在编程中的两种含义

1，封装——包装：

将一段重复使用的代码包装到一个方法中，称为包装

2，面向对象语言中的封装

使用不同的访问权限修饰符，控制类中的成员是否可以对外可见

面向对象语言封装：

将类中的某些信息隐藏在类的内部，不让外界知道，或不让外界直接访问，可以提供专门的公共的方法进行访问

问题：name，age，等可以在类的外部进行操作，但在外部进行赋值时，所在类没有办法对所赋的值进行控制，或不好控制

解决方法：

可以使用私有权限private将name和age隐藏起来，将其定义为私有成员变量

然后提供公开的方法进行访问

package fengzhuang.Study1;

public class Person {


    private String name;
    private int age;
    /*
    使用私有权限访问符将name和age定义为私有成员变量
    然后使用getname，setname，getage，setage等公共方法被对象使用
     */


    public void Setname(String name){
        if (name.length()>=2&&name.length()<=6){
            this.name = name ;
        }
    }

    public void SetAge(int age){
        if (age>=0&&age<=120){
            this.age = age;
        }
    }
    //对成员变量进行隐藏起来，提供公共方法进行访问

    public String GetName(){
        return this.name;
    }

    public int GetAge(){
        return this.age;
    }
    //获取所赋的成员变量

    public void eat(){
        System.out.println(this.name+"吃东西");
        drink();
    }

    private void drink(){
        System.out.println(this.name+"喝水");
    }



}