JavaSE笔记08 初进面向对象+封装

JavaSE笔记08 初进面向对象+封装

一.面向过程和面向对象：

• 面向过程POP（Process-Oriented Programming）：
  强调的是系统的数据被加工处理的过程，数据仅仅作为输入和输出存在，在程序设计中主要以函数或者过程为程序的基本组织方式。比如说，C语言中，数据与处理这些数据的函数是分离的，程序的最小单元是函数
• 面向对象（Object Oriented Programming）：
  是以对象为中心，将对象的内部组织与外部环境区别开来，将表征对象的内部属性数据与外部隔离开来，其行为与属性构成了一个整体，而系统功能则表现为一系列对象之间的相互作用的序列，能更加形象的模拟或表达现实世界

面向过程	面向对象
以函数（方法）为最小单位	以类/对象为最小单位，类包括：数据+方法
以过程，步骤为主，考虑怎么做	以对象（谁）为主，考虑谁来做，谁能做

注意：
面向对象的开发过程：其实就是不断创造对象，使用对象，指挥对象做事情
面向对象的设计过程：就是管理和维护对象之间的关系

二.创建类调用成员变量和成员方法：

创建一个人类(定义类中的成员变量与方法）：
代码演示：

public class Person {
    //成员变量
    String name="张三";
    int age=20;
    char sex='男';
    //成员方法
    public void eat(){
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
    public void playGame(){
        System.out.println("玩游戏");
    }
}

public class Test {
    public static void main(String[] args) {
        //类不能直接使用，要使用，就必须对该类进行实例化，
      Person  person=new Person();
        // 通过该类的对象，来使用类中的属性和功能
       String username= person.name; //调用类中的属性 对象名.成员变量名
       int age= person.age;
       char sex=person.sex;
        System.out.println(username);
        System.out.println(age);
        System.out.println(sex);
        //调用类中的功能
        person.eat();
        person.sleep();
        person.playGame();
        System.out.println("===================================");
        //一个类可以创建很多他的对象
        Person person2 = new Person();
        //你可以给成员变量重写赋值
        person2.name="王五";
        person2.age=30;
        person2.sex='女';
        System.out.println(person2.name);
        System.out.println(person2.age);
        System.out.println(person2.sex);
        //类中的方法，每一个该类的对象，都可以调用
        person2.playGame();
        person2.eat();
        person2.sleep();
    }
}

1.一个对象的内存图解：

代码演示：

public class Student {
    String name="zhangsan";
    int age;
    public void eat(){
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
}

public class MyTest {
    public static void main(String[] args) {
        Student student = new Student();
        student.name="李四";
        student.age=24;
        System.out.println(student.name);
        System.out.println(student.age);
        student.sleep();
        student.eat();
    }
}

内存图解：

2.两个对象的内存图解：

代码：

public class Student {
    String name="zhangsan";
    int age;
    public void eat(){
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
}

public class Test2 {
    public static void main(String[] args) {
        Student student = new Student();
        System.out.println(student);
        student.name="王老虎";
        student.age=30;
        System.out.println(student.name);
        System.out.println(student.age);
        System.out.println("=======================");
        Student student2 = new Student();
        System.out.println(student2);
        student2.name="王百万";
        student2.age=40;
        System.out.println(student2.name);
        System.out.println(student2.age);
    }
}

内存图解：

3.三个对象的内存图解：

代码演示：

public class Student {
    String name="zhangsan";
    int age;
    public void eat(){
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
}
public class Test3 {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.name="郭富城";
        s1.age=50;
        Student s2 = new Student();
        s2.name="刘德华";
        s2.age=40;
        Student s3=s1;
        s3.name="张学友";
        s3.age=30;
        System.out.println(s1.name); //张学友
        System.out.println(s1.age); //30
        System.out.println(s2.name); //刘德华
        System.out.println(s2.age); //40
        System.out.println(s3.name); //张学友
        System.out.println(s3.age); //30
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
    }
}

内存图解：

三.成员变量与局部变量的区别：

成员变量	局部变量
成员变量:定义在类中，方法外的变量	局部变量:定义在方法中或方法声明上的变量（形参）
成员变量：属于对象	局部变量属于方法
成员变量，随着对象的创建，而产生，随着对象的消失而消失	局部变量随着方法的调用而产生，随着方法的调用完毕而消失
成员变量存在内存	局部变量存在栈内存
成员变量，有默认值	局部变量，没有默认值，必须赋值才能使用

注意：
当局部变量与成员变量重名时，变量的范围会采取就近原则
Java中的传参问题：
对于形式参数:

• 基本类型：形式参数的改变不影响实际参数
• 引用类型：形式参数的改变直接影响实际参数

方法的参数是类名： 如果你看到了一个方法的形式参数是一个类 类型(引用类型)，这里其实需要的是该类的对象

四.private关键字：

private关键字的特点：

• 是一个权限修饰符
• 可以修饰成员变量和成员方法
• 被其修饰的成员只能在本类中被访问

class Cat {
    protected int aa;
    public int num;
    String sex;
    //定义成员变量
    private String name;
    //private 私有的，是一个权限修饰符，可以修饰成员变量和成员方法，
    //被修饰的成员，只能在本类中访问，外界无法直接访问。
    //权限修饰符：public（任意地方） > protected > 缺省的> private(本类)
    private int age;

   public void setAge(int nl){
       if(nl>=0&&nl<=15){
           age = nl;
       }
   }

   public int getAge(){
       return age;
   }

   public void setName(String mz){
       name=mz;
   }
   public String getName(){
       return name;
   }

   private void catchMouse(){
       System.out.println("猫抓老鼠");
   }

   public void show(){
       catchMouse();
   }
}
public class MyTest {
    public static void main(String[] args) {
        Cat cat = new Cat();
        //对象名.成员变量名  可以给成员变量赋值，也可以获取成员变量的值。
        //如果采用 对象名.成员变量名 这种方式，会把一些不合理的数据设置上去，那这不是我们想要的。
        //那怎么解决，我们可以把 对象名.成员变量名 这种方式 给他屏蔽调用，不允许用这种方式，来访问成员变量。
        /*
        cat.name="小花";
        cat.age = 50;
        System.out.println(cat.name);
        System.out.println(cat.age);
         */
        cat.setName("胖橘");
        cat.setAge(10);
        int age = cat.getAge();
        System.out.println(age);
        String name = cat.getName();
        System.out.println(name);
        String sex = cat.sex;
        int aa = cat.aa;
        int num = cat.num;


        // cat.catchMouse();
        cat.show();

    }
}

五.this关键字：

当我们的局部变量和成员变量相同的时候,如果我们不使用this关键字,那么会导致一个问题:就是局部变量隐藏了成员变量的问题
this关键字特点：
是当前类的对象引用
简单的记，它就代表当前类的一个对象。 谁调用这个方法,那么该方法的内部的this就代表谁

public class MyTest {
    public static void main(String[] args) {
        Animal animal = new Animal();
        System.out.println("调用者的地址值:"+animal);
        animal.setName("大象");
        animal.setAge(20);
        String name = animal.getName();
        int age = animal.getAge();
        System.out.println(name);
        System.out.println(age);
    }
}

class Animal {
    private String name;
    private int age;
    public void setName(String name){
        //this 他代表的是该类的一个引用，你可以理解该类的一个对象，他代表哪个对象呢？哪个对象对象调用这个方法，那么方法中的this就代表谁。
        System.out.println("放发中的this:"+this);
        this.name=name;
        //animal.name=name;
    }
    public void setAge(int age){
        System.out.println("放发中的this:" + this);
        this.age=age;
        //animal.age=age;
    }
    public String getName(){
        return this.name;
    }
    public int getAge(){
        return this.age;
    }
}