day4 java第四天

4.1set函数

为什么会有set函数
    public class Pp {
   String name;
   int age;
   String adress;
}
     public static void main(String[] args) {
        Pp p1 = new Pp();
        p1.age=18;
        p1.name="张三";
        p1.adress="北京";
        Pp p2=new Pp();
        p2.age=-19;
        p2.name="李四";
        p2.adress="南京";
        
    }
像上面写的这种年龄在语法中因为实在int数据类型的范围内，所以电脑不会报错，并且会正常输出，但是这种不符合常理，所以我们需要进行判断：
      public static void main(String[] args) {
       int a=18;
        Pp p1 = new Pp();
       if(a>0){
           p1.age=a;
       }else{
           p1.age=0;
       }
        p1.name="张三";
        p1.adress="北京";
        System.out.println(p1.age);
        int b=-18;
        Pp p2=new Pp();
        if(b>0){
            p2.age=b;
        }else{
            p2.age=0;
        }
        System.out.println(p2.age);
        p2.name="李四";
        p2.adress="南京";
    }
在这种我们进行了判断可以看出给出的最后结果是符合了常理，但是如果我们需要写入和很多的人员信息那则是一件很繁琐的事情，于是接下来我们就可以尝试引用set方法：
    
   public class Pp {
   String name;
   int age;
   String adress;
    public void  setAge(int age){
        if(age>0){
            this.age=age;
        }else{
            this.age=0;
        }
    }
} 
 int b=18;
        Pp p1 = new Pp();
        p1.setAge(b);
        p1.name="张三";
        p1.adress="北京";
        System.out.println(p1.age);
        int a=-18;
        Pp p2=new Pp();
        p2.setAge(a);
        p2.name="李四";
        p2.adress="南京";
        System.out.println(p2.age);
        ... 
如上面这种就可以实现再添加新的人员信息的时候就可以直接调用set函数来判断输入年龄的时候输出的值

4.2权限修饰符

为什么要权限修饰符
        public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入您的年龄");
        int a = scanner.nextInt();
        Pp pp = new Pp();
        pp.age = a;
        Pp p1 = new Pp();
        int b = scanner.nextInt();
        p1.setAge(b);
    }
public class Pp {
   String name;
   int age;
   String adress;
    public void  setAge(int age){
        if(age>0){
            this.age=age;
        }else{
            this.age=0;
        }
    }
}
像上面这种就会出现pp.age=a；形式这种样式给到成员变量赋值，而是使用  p1.setAge(b);；形式赋值，所以我们需要将pp.age=a;形式取消，所以我们需要使用到权限修饰符；
   如何使用权限修饰符
    private int age
    权限修饰符
    public    公共权限。修饰的内容当前类中任意包都可以访问修饰的内容：  成员变量   函数  类
    
    protected   包权限和继承权限。修饰的内容只能在同一个包中访问，如果不在同一个包中如果是有继承关系也可以访问。 
    修饰的内容  ：成员变量  函数 
    default /friendly   包权限，修饰的内容只能在同一个包中访问，其他包无法访问。注意不是添加default关键字代表包权限，而是什么都不写代表包权限
    修饰的内容：成员变量  函数  类
    private  私有权限，修饰的内容只能在当前类中使用，外面无法使用【反射不考虑】
    修饰的内容：成员变量  函数
    

4.3get函数

为什么要用get函数
    因为当我们把 private int age;变成了一个私有权限，只能在此类中使用，这样就只能向这个类中存值，但是却取不出
        public int getAge(){
        return this.age;
    }
当我们运用get变量时就可以使用它然后进行返回值
            int vv=p1.getAge();
        System.out.println(vv);
这样就可以进行输出数据了

4.4数据模型类

在漫长的开发中，java对象用来存取数据，但是期间经历了很多的问题，后来有解决问题，再写代码都会规避问题，最后总结出一套java存储对象类 创建的方式：
    public class  类名{
        
        私有成员变量
            
        set和get函数
            
        tostring
            
    }
类：
    测试类：  javatest
    工具类：  javatool
    数据模型类： Date model
    数据模型类 作用是用来存储数据，开发工具都自带  模型类生成功能
    public class Datemodel {
    
     private  String  name;
     private  int     age;
     private  String  address;
​
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    public String getAddress() {
        return address;
    }
​
    public void setAddress(String address) {
        this.address = address;
    }
​
    @Override
    public String toString() {
        return "Datemodel{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                '}';
    }
}

4.5toString函数作用

public static void main(String[] args) {
        Pp p1 = new Pp();
        p1.setAge(-18);
        int vv=p1.getAge();
        System.out.println(p1);
    }
当我们使用 System.out.println输出对象的时候，如果当前对象写了tostring函数则按照写了的格式输出，如果没有写则会按照object的tostring函数输出：com.gk.day1.Pp@16d3586
                        权限定名        hashcode码值
    当我呢吧在Pp中添加了tostring的时候：
      @Override
    public String toString() {
        return "Pp{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", adress='" + adress + '\'' +
                '}';
    }
    则在输出的结果是：
        Pp{name='null', age=0, adress='null'}

4.6构造函数

构造函数：是一种特殊的方法。
构造函数作用：主要用来创建对象初始化对象，即为对象成员变量付初始值，
构造函数的调用：总与new运算符一起使用在创建对象的语句中。
构造函数重载：特别的一个类可以有多个构造函数，可根据其参数个数的不同或参数类型的不同来区分它们，即构造函数的重载。
   当我们创建  Pp p1 = new Pp();此时我们的 new Pp()的Pp()就是构造函数，构造函数特点：
1.一个类如果不写 在编译之后就会生成一个 公共无参数的构造函数 
    public Pp(){};
2.构造函数不写赶回值类型，如果写了就不在是构造函数 虽然不会报错 但是会有黄色警告：  
  Method name 'People' is the same as its class name  
  Inspection info: Reports methods being named identically to their class. 
  A method with such a name may be easily mistaken for a constructor
                        public   void   Pp(){};
 3.构造函数的名字要和类相同 如果不相同则会报错：
 Invalid method declaration; return type required：“必须返回的类型”
 public pp(){};
 这个就是名字小写与类名不同
 4.如果定义了有参数的构造函数 此时就不会自动生成公共五参数的构造函数了

4.7构造函数作用

public class Pp {
  private String name;
  private int age;
  private String adress;
    public void setAge(int age){
        if(age>0){
            this.age=age;
        }else{
            this.age=0;
        }
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public void setAdress(String adress) {
        this.adress = adress;
    }
​
    public String getName() {
        return name;
    }
​
    public String getAdress() {
        return adress;
    }
​
    public int getAge(){
        return this.age;
    }
​
    @Override
    public String toString() {
        return "Pp{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", adress='" + adress + '\'' +
                '}';
    }
}
​
   public static void main(String[] args) {
        Pp p1 = new Pp();
        p1.setAge(-18);
        p1.setName("张三");
        p1.setAdress("北京");
        int vv=p1.getAge();
        System.out.println(p1);
        Pp p2=new Pp();
        p2.setName("李四");
        p2.setAge(19);
        p2.setAdress("南京");
        System.out.println(p2);
    }
像这种添加数据就会非常显得麻烦，于是我们引用构造函数即可如下：
    利用构造函数并且里面增加了参数
        public Pp(String name, int age, String adress) {
        this.name = name;
        this.age = age;
        this.adress = adress;
    }
   public static void main(String[] args) {
       Pp p1= new Pp("李四",18,"北京");
       Pp p2= new Pp("张三",19,"南京");
        System.out.println(p1);
        System.out.println(p2);
    }
如果这样创建一个有参数的构造函数，那样就可以直接在创建对象的时候直接吧他们相对应的数据添加里面

4.8构造函数重载

当我们的类 只添加了有参数的构造函数（目的是创建对象的时候 同时完成数据的赋值）有的时候我们需要创建对象 但是暂时还没有数据
    此时我们的代码就会有问题
      public static void main(String[] args) {
       Pp p1= new Pp("李四",18,"北京");
       Pp p2= new Pp(,,);
        System.out.println(p1);
        System.out.println(p2);
    }
这个时候的P2就会因为没有参数而导致了系统报错，而不能进行输出或则后续的显示。
    
    因此在这个时候，我们在创建一个有参数的构造函数的时候也要同时创建一个公共无参数的构造函数：
     public Pp(){}
  public Pp(String name, int age, String adress) {
        this.name = name;
        this.age = age;
        this.adress = adress;
    }
创建这个之后呢就可以在选择创建类的时候先为空，后续在进行添加数据
    同时在此时我们就发现 俩构造函数 函数的名字一样相同 但是两个却能共存 此时就发生了函数的重载 overload
    在java中同一个类中 函数名相同 参数列表不同则函数可以共存 这个特点就成为 函数的重载参数列表不同具体值 参数的个数 参数的类型 参数的顺序；
    为什么这个语法/什么时候使用函数重载语法？
    此时我们其实天天在都在使用函数的重载 系统的输出语句 就很神奇：相同的函数 居然能传递不同的参数
      public static void main(String[] args) {
        System.out.println(123);
        System.out.println("asf");
        System.out.println("你好");
        System.out.println(true);
    }
此时我们可以利用Ctrl+鼠标左键可以查看底层代码
    
     public void println(boolean x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }
    public void println(char x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }
    public void println(int x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }
    public void println(long x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }
    public void println(float x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }
    public void println(double x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }
    public void println(char x[]) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }
    public void println(String x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }
    public void println(Object x) {
        String s = String.valueOf(x);
        synchronized (this) {
            print(s);
            newLine();
        }
    }