自学java （day11）：类和对象

//java中，程序员不能直接操作堆内存，只能通过引用去访问堆内存中的实例变量，访问格式是：：：引用.变量名

//要是想要引用自己创建的类，就要在当前的包里创建一个公共的类（public）
public class DiaoYong {
    public static void main(String[] args){

            //通过一个类可以实例化N个对象
            //实例化就想的语法： new 类名();
            //new是java语言中的一个运算符
            //new运算符的作用是创建对象，在JVM堆内存当中开辟新的内存空间    new
            //U是一个引用数据类型
            //s1是一个变量名
            //s1是一个局部变量【在栈内存中存储】，可以叫做引用，作用是赋值，，，引用是变量，它保存了另一个java对象的地址【在堆内存中】
        U s1=new U();

            //读取数据：引用.变量名
            //第一种方式
        int uAge=s1.age;
        String uName=s1.name;//没有修改数据，就默认空（null）
        int uXuehao=s1.xuehao;

        System.out.println("年龄："+uAge);
        System.out.println("姓名："+uName);
        System.out.println("学号："+uXuehao);

            //修改数据：引用.变量名=值
        s1.age=77;//修改数据
        s1.xuehao=1;
       s1.name="卢";
        System.out.println(s1.age);//77
        System.out.println(s1.name);//null
        System.out.println(s1.xuehao);
    }

}
class U {

    //xuehao   age   name   都属于实例变量

    int xuehao;
    int age;
    String name;
}


/**
        局部变量在栈内存中存储
        成员变量的实例变量在堆内存中的java（实例）对象中存储
 */

2、

    //用户类
public class User {

        //下面这些是属性【都是成员变量的实例变量】
        //用户编号
        //no是一个实例变量
        int no;

        //用户名
        //name是一个实例变量
        //String是引用数据类型，，表示字符串
        //name是一个引用，存在于栈内存中
        String name;

        //家庭住址
        //Address是一个引用数据类型，，表示家庭住址
        //addr是一个实例变量  是一个引用
        Address addr;

}

    //家庭住址类
class Address{

    //一下这三个也是属性
                 //城市
            String city;

            //街道
            String street;

            //邮编
            String zipcode;

    }

public class DiaoYongUandAdd {
    public static void main(String[] args){

        //创建User对象
        //u是局部变量
        //u是引用  存储在栈内存中，指向堆内存的User对象  引用是一个变量
        User u=new User();

        //输出User对象内部实例变量的值
        System.out.println("用户编号："+u.no);//0
        System.out.println("用户名："+u.name);//null
        System.out.println("家庭住址："+u.addr);//null

        //修改User对象内部实例变量的值
        u.no=35;
        u.name="卢";

        //子继承父
 //         u.addr=new Address();//等同于下边这两行
        Address a=new Address();
        u.addr=a; // 一行变两行

 //       u.addr.city="衡水";
        a.city="北京";
        u.addr.street="搭设街道";
        u.addr.zipcode="05616";

        //输出User对象内部实例变量的值
        System.out.println("用户编号："+u.no);//35
        System.out.println("用户名："+u.name);//卢
        System.out.println("家庭住址："+u.addr);//家庭住址：ceshi.Address@7cd84586
        System.out.println(u.name+"居住在"+a.city+"这个城市");//卢居住在北京这个城市
  //      System.out.println(u.name+"居住在"+u.addr.city+"这个城市");//卢居住在衡水这个城市
        System.out.println(u.name+"居住在"+u.addr.street+"这个街道");//  卢居住在搭设这个街道
        System.out.println(u.name+"的邮编是"+u.addr.zipcode);//  卢的邮编是05616

    }
}

3、类的关联

        //类的关联


public class DiaoYongHnsandW {
    public static void main(String[] args){

        //创建一个丈夫对象
        Husband huangxiaoming=new Husband();
        huangxiaoming.name="黄晓明";

        //创建一个妻子对象
        Wife baby=new Wife();
        baby.name="杨颖";

        //结婚【通过丈夫可以找到妻子，通过妻子可以找到丈夫】
        huangxiaoming.w=baby;
        baby.h=huangxiaoming;

        //得到以上黄晓明妻子的名字
        System.out.println(huangxiaoming.name+"的妻子是"+huangxiaoming.w.name);

    }
}

//丈夫类
public class Husband {

    //姓名
    String name;

    //丈夫对象应包含妻子引用
    Wife w;
}
class Wife{

    //姓名
    String name;

    //妻子对象应包含丈夫引用
    Husband h;
}

import java.util.concurrent.Callable;

public class DiaoYongCustomer {
    public static void main(String[] args){
        Customer c=new Customer();
        System.out.println(c.id);

        c=null;
        //编译可以通过
        //空引用访问“实例”相关的数据一定会出现空指针异常 java.lang.NullPointerException
        //“实例”相关的数据表示，这个数据的访问必须有对象的参与
        System.out.println(c.id);
    }
}
class Customer {

    int id;
}

面向对象的三大特征：封装

/**
    面向对象的三大特征：
    --封装
    --继承
    --多态

    当前主要讲封装，为什么要封装？封装的好处？
      封装的好处
       1、封装之后，对于那个事物来说，看不到这个事物比较复杂的一面，只能看到事物简单的一面
       复杂性封装，对外提供简单的操作入口。照相机就是一个简单的封装的例子，照相机实现原理比较复杂，使用比较简单。电视机也是

       2、封装之后才会实现真正的“对象”，真正的“独立体”

       3、封装就意味着以后的程序可以重复使用。并且这个事物应该适应力强，在任何场所都能使用

       4、封装之后，对于事物本身，提高了安全性
 */
public class FengZhuang {
    public static void main(String[] args){

        //创建 FengZhuang1对象
        FengZhuang1 user = new FengZhuang1();

        //age 在 DuiXiang.FengZhuang1 中是 private 访问控制
        //age属于私有化属性，在外部程序中不能直接访问
        //System.out.println(user.age);

        //修改setter
        user.setAge(100);

        //读取getter
        user.getAge();
        System.out.println( user.getAge());

    }

}

/**
    封装的步骤：
     1、所有属性私有化，使用 private 关键字进行修饰，private表示私有的，修饰的所有数据只能在本类中访问

     2、对外提供简单的操作入口，也就是说以后外边的程序想要访问age属性，必须通过简单的入口进行访问
        ----对外提供连个方法get方法和set方法
        ----想读取age属性调用get方法
        ----想修改age属性调用set方法

     3、set方法的命名规范：
            public  void  set+属性名首字母大写（形参）{}
                引用这里的例子：：：
                    public void setAge（int a）{
                        age=a；
                    }

       4、get方法的命名规范：
            public  int getAge（）{
                return age；
            }

    回想一下，属性的访问形式？
    ----读取数据   ，  读取【get】
    ----修改数据   ，  修改【set】

    需要记住：
    ---getter和setter方法没有static关键字
    ---有static关键字修饰的方法怎么调用：类名.方法名（实参）；
    ---没有static关键字修饰的方法怎么调用：引用.方法名（实参）；

 */
public class FengZhuang1 {

    //属性私有化
    private int age;

    //setter(修改)
    public void setAge(int a){

       // age=a;

        //直接在这写代码
        if(a<0||a>150){
            System.out.println("输入的年龄不合法");
            return ;
        }
        age=a;
    }

    //getter(读取)
    public int getAge(){
        return age;
    }
}