Java面向对象：什么是面向对象，类与对象的创建，构造器，封装，继承

//对象1 类
public class 对象1 {
     //mian方法
    public static void main(String[] args) {
       /*
       修饰符  返回值类型 方法名（。。。）{
        //方法体
        return 返回值;
        }
        */
    }
      public String sayHello(){
         //return,方法就等于结束
        return "Hello,world";
        }
       public  void print(){
          return;
       }
     public int sum(int a,int b) { //形式参数
       return a>b ? a:b; //a大于b ？结果为a,否则为b. //三元运算符！
     }
     //数组下标越界异常：Arrayindexoutofbounds
      //这才是一个最完整的一个方法。
    public  void result(String file) throws IOException { //读取一个文件String file，
        // throws 就是抛出的意思，抛出一个IOException异常。
      }
    }
//类
public class 对象2 {
    //属性 ：字段
  String name; //null
  int age; //0
     //方法
    public void study(){
        System.out.println (this.name+"在学习");
    }
}
//一个项目只存在一个mian方法
public class stion2 {
    public static void main(String[] args) {
       //类是抽象的，需要实例化
       //类实例化后会返回一个自己的对象！
        //对象2对象就是一个对象2类的具体实例！
        对象2 xiangming = new 对象2 ();
        对象2 xiaohong = new 对象2 ();
        xiangming.name = "小明";
        xiangming.age = 3;
        System.out.println (xiangming.name);
        System.out.println (xiangming.age);
        xiangming.name = "小红 ";
        xiangming.age = 3;
        System.out.println (xiangming.name);
        System.out.println (xiangming.age);
    }
}
//创建对象内存分析
public class Pet {
    String name; //宠物名字
    int age; //年龄

    //无参构造
    public  void shout(){
        System.out.println ("叫了一声！");

   }
}

//public class Pet1 {
   // public static void main(String[] args) {
   //     Pet dog = new Pet ();
     //   dog.name = "旺财";
     //   dog.age = 3;
      //  dog.shout ();

       // System.out.println (dog.name);
       // System.out.println (dog.age);
   // }

//}
//java ---> class
public class gouzao1 {
    //一个类即使什么都不写,他也会存在一个方法
    //显示定义构造器
    //初始化
    //有参和无参 alt+lnsert 一键生成
    String name;
   int age;
    // 1.使用new关键字,本质是在调用构造器
    // 2.用来初始化值
    public gouzao1() { //无参构造

    }

    //有参构造：一旦定义了有参构造,
    // 无参构造就必须显示定义，否则无效

    public gouzao1(String name) {
        this.name =name;
    }

    public gouzao1(String name,int age) {
        this.name = name;
        this.age = age;
    }
}
//public class gouzao2 {
    //public static void main(String[] args) {
        //new 实例化一个对象
       // gouzao1 gouzao1 = new gouzao1 ("binge",3);
      //  System.out.println (gouzao1.name);//zahngsan

   // }
//}

/*
构造器
 1.和类名相同
 2.没有返回值
作用
 1.new 本质在调用构造方法
 2.初始化对象的值
 注意点
 1.定义有参构造之后,如果想使用无参构造,显示的定义一个无参的构造
 this. = 参数传进来的值
 */
  //类  private:属性私有
public class fenzhuang1 {
      //属性私有
      private String name; //名字
      private int id; //学号
      private char sex;//性别
      private int age; //年龄
      //提供一些可以操作这个属性的方法
      //提供一些的public 的 个get set 的方法

      //get获得这个数据
      public String getName() {
          return this.name;
      }

      //给这个数据设置值
      public void setName(String name) {
          this.name = name;
      }
      //alt+insert,自动生成 get set方法

      public int getAge() {
          return age;
      }

      public void setAge(int age) {
          //不合法的
          if (age > 120 || age < 0) {//如果这个年龄大于120岁或者
              // 年龄小于0岁
             this.age = 3;//年龄等于他输入的值,否则的话age =3岁
          }else{
              this.age = age;
          }
      }

      public char getSex() {
          return sex;
      }

      public void setSex(char sex) {
          this.sex = sex;
      }

      public int getId() {
          return id;
      }

      public void setId(int id) {
          this.id = id;
      }
  }

//public class fenzhuang2 {
    /*
      封装的好处
       1.提高程序的安全性,保护数据
       2.隐藏代码的实现细节
       3.统一接口
       属性私有 get set
       4.系统的可维护性增加了
     */
   // public static void main(String[] args) {
      //  fenzhuang1 s1 = new fenzhuang1 ();
      //  s1.setName ("张三");
        //方法名,参数列表
      //  System.out.println (s1.getName ());
      //  s1.setAge (999); //不合法的
      //  System.out.println (s1.getAge ());
    //}
//}
//继承=相对于动物,比如 爬行 哺乳动物等等
//继承就是什么东西继承给他的意思
public class jicheng1 { //人：父类(基类)
  //public 公共的 private 私有的
   public  int money = 10_000;

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    public  void say(){

     System.out.println ("说了一句话");

 }
}

//学生 人：子类(派生类)
//public class jicheng2 extends jicheng1 {

//}

//jicheng3  人：子类(派生类)
//public class jicheng3 extends jicheng1{
    //extends 就是扩展,子类是父类的扩展
//}

//public class 调用 {
 //   public static void main(String[] args) {
       // jicheng2 jicheng2  = new jicheng2();
     //   jicheng2.say (); //jicheng2继承了父类,就拥有了父类的所有方法。
      //  System.out.println (jicheng2.money);
    //}

//}