Java学习 DAY07 对象和类

面向对象的引入

面向对象本质是一种编程范式（思考方式）
面向过程：关注的是代码的实现细节
面向对象：先把代码实现细节整合到对象中，找到这个对象就能拥有对象的功能
面向对象基于面向过程，面向对象优于面向过程？如果我们场景比较简单优先推荐面向过程，如果场景很复杂优先推荐面向对象

对象和类之间的关系
对一类对象来进行抽取，把共有的特征信息抽取成了属性，把共有的行为信息抽取成了方法，把这一类对象抽取成了类。类是对对象的概括，对象是对类的具体实现。

构造方法

a.构造方法
b.1.与类同名 2.没有返回值类型
c.有参构造用于属性初始化，支持构造方法重载
d.当类中没有定义任何形式的构造方法jvm会在底层默认添加无参构造，如果类中已经定义构造方法那么底层就不会再添加无参构造
e.类中至少含有一个构造方法

public class MethodDemo2 {
    public static void main(String[] args) {
        //创建person类对象ｐ
        //构造方法---构建对象
        Person p = new Person("tom");
        //给对象的属性进行赋值
        //.代表“的”的意思
        p.gender = '男';
        p.age = 66;
        //输出
        System.out.println(p.name + "," + p.gender + "," + p.age);
        //调用方法
        p.sleep();
        p.eat();


        //创建person类对象
        Person p1 = new Person();
        //给对象的属性进行赋值
        p1.name = "heh";
        p1.gender = '女';
        p1.age = 55;
        //输出
        System.out.println(p1.name + "," + p1.gender + "," + p1.age);
        //调用方法
        p1.sleep();
        p1.eat();
    }
}


//代表人的类
class Person{
    //特征---属性
    //不加static的属性就是非静态属性
    //成员变量
    String name;
    char gender;
    int age;


    //当类中没有定义任何形式的构造方法jvm默认在底层添加无参构造
    //当类中定义构造方法底层就不会默认添加无参构造
    //无参构造
    //1.没有返回值类型  2.与类同名
    public  Person(){}
    //普通方法可以与类同名
    //public void Person(){}

    //有参构造---对象属性初始化
    //java支持构造方法重载
    public Person(String name){//方法有就近原则
        //this代表我们当前类的对象
        this.name = name;

    }

    //行为---方法---成员方法

    public void eat() {
        int age = 1;//局部变量

        System.out.println(name + "在吃饭...");
    }
    public void sleep() {

        System.out.println(name + "在睡觉...");
    }
}

java中所有的非静态属性和方法要由对象调用

this

a.关键字，代表当前类的对象
b.可以代表当前类还没有产生的对象，代表当前类刚创建的对象，代表当前类正在使用的对象。this是灵活的指代（虚拟），可以指代成当前类正在活动的对象
c.this语句—在同一个类中的构造方法里调用别的构造方法，首行

public class ThisDemo {
    public static void main(String[] args) {
        //常见对象
        Student s1 = new Student();
        //this可以代表当前类刚创建对象
        System.out.println("s1:" + s1);
        //创建对象
        Student s2 = new Student("tom");
        //this是一个灵活的指代
        System.out.println("s2:" + s2);
        //this指代成当前类正在使用的对象
        s1.study();
        s2.study();

    }
}


//代表学生的类
class Student{
    //属性
    String name;
    int age;
    char gender;


    //无参构造
    public  Student(){
        System.out.println("this:" + this);
    }


    //有参构造
    public Student(int age){
        this();
    }

    //有参构造
    public  Student(String name){
        //调用别的构造方法
        //Student();调用不到
        //this语句---调用别的构造方法   要在首行
        this(1);
        this.name = name;
        System.out.println("this:" + this);
    }

    //方法
    public void study(){
        //this可以代表当前类还没有创建对象
        System.out.println(this.name + "在学习...");
        //
        System.out.println("this:" + this);
    }

}

构造代码块
a.在方法外类内{}
b.属性初始化
c.优先于所有的构造方法先执行

局部代码块
a.方法内{}
b.控制变量的生命周期，提供内存利用率

public class ObjectDemo2 {
    public static void main(String[] args) {
        //
        Baby b = new Baby();
        //
        System.out.println(b.name + "," + b.age);
    }
}


//代表婴儿的类---创建对象就是真是的婴儿
//要求:不管怎么出生，婴儿的名字叫莉莉，年龄是一岁
class Baby{
    //属性
    String name;
    int age;
    char gender;



    //构造代码块
    //优先于所有的构造方法先执行
    //属性初始化
    {
        this.name = "莉莉";
        this.age = 1;
    }

    //无参构造---婴儿没有名字没有年龄
    public Baby(){
        /*this.name = "莉莉";
        this.age = 1;*/
    }


    //有参构造----婴儿出生时有名字
    public  Baby(String name){
        //this.name = name;

         /* this.name = "莉莉";
        this.age = 1;*/
    }

    //婴儿出生时有名字也有年龄
    public  Baby(String name,int age){
      /*  this.name = name;
        this.age = age;*/

       /* this.name = "莉莉";
        this.age = 1;*/
    }



    //方法
    public void cry(){
        System.out.println(name + "在嗷嗷的哭......");
    }
}

成员变量与局部变量的区别

  1.位置
          成员变量：方法外类内
          局部变量：方法内
  2.适用范围
          成员变量：整个类
          局部变量：整个方法
  3.内存
          成员变量：堆
          局部变量：栈
  4.生命周期
          成员变量：随着类创建对象而出现，随着对象被挥手而消失
          局部变量：当方法被调用时才出现，随着方法执行结束而消失

面向对象的特征
封装、继承、多态（抽象）

封装

体现形式—方法，属性私有化并且提供公共的访问方式来进行正常取值和赋值，提高代码数据安全性。

public class FZDemo {
    public static void main(String[] args) {
        //创建代表人的类的对象
        Person p = new Person();
        //给对象属性赋值
        p.setName("heh");
        //调用方法间接给私有化属性进行赋值
        p.setAge(-10);
        p.setGender('男');
        //调用方法间接给私有化属性进行取值
        System.out.println(p.getName() + "," + p.getAge() + "," + p.getGender());
    }
}

//代表人的类
class  Person{
    //属性
    private  String name;
    //私有化属性，只能在我们的本类中直接使用
    private int age;
    private char gender;

    //Alt+Insert---Generate

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        if (age < 0) {
            System.out.println("数据有误!!!");
        }else{
            this.age = age;
        }
    }

    public void setGender(char gender) {
        this.gender = gender;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public char getGender() {
        return gender;
    }


    /*//定义方法间接的给私有化属性进行赋值
    public void setAge(int age){
        if (age < 0) {
            System.out.println("数据有误!!!");
        }else{
            this.age = age;
        }
    }

    //间接定义方法给私有化属性进行取值
    public int getAge() {
        return age;
    }*/

    /*//有参构造
    public Person(int age){
        if (age < 0) {
            System.out.println("数据有误!!!");
        }else{
            this.age = age;
        }
    }*/
}