4.面向对象

//创建Student实体类
public class Student{
    String ID;  
    String name;  
    int age;   
    char gender;  
    double score;
  
    //设计方法
  
    public String toString(){
        //syso("中国你好");
        return "ID:"+this.ID
    }
  
}
​
​
    Student s1 = new Student();
    syso(s1.toString());
​
    //测试类中
    //创建Student类型的数组 用于批量保存学生对象
    Student[] ss = new Student[2];
​
    //通过循环 批量保存
    for(int i =0;i<ss.length;i++){
        //要给数组的每一个房间 创建一个学生对象
        ss[i] = new Student();
        syso("请输入xxx");
        ss[i].ID= input.next();
      
        ss[i].name = input.next();
      
        ss[i].age = input.nextInt();
        ss[i].gender = input.next().charAt();
        ss[i].score = input.nextDouble();
    }
​
    //int[] nums = new int[3];
    //nums[0] = 100;
​
    //for(int n : nums){
    //    n=1000;
    //}
    //syso(nums[0]);//100
​
​
    for(int i =0;i<nums.length;i++){
        nums[i] = input.nextInt();
    }
    String name = "";
    String name = new String("");
​
    //使用增强for循环展示所有元素
    for(Student s : ss){
      
        if(s!=null){
            syso(s.ID+"\t"+s.name+"\t"+s.age+"\t"+s.gender+"\t"+s.score);
        }
    }

  
public class Test{
  
    public static int num; //0
​
    public static void main(String[] args){
        //方法体  实现功能
        public static int age;//报错  不能添加访问修饰符  也不能添加静态
      
        syso(age);//局部变量 没有赋值使用则报错
      
        syso(num);//0
    }
  
  
  
}

类下直接编写
static{
    静态代码块 //静态代码块中的代码 只要加载就会执行
            //只能调用到在他之前声明的静态属性
}

    //使用类时 第一时间加载所有静态资源 且只加载一次  ==》普通资源 在new对象时加载
    //0.静态代码块 加载同时执行        ===》静态方法虽然已经加载 但需要调用才执行
            //静态代码块 只能调用到在他之前声明的静态属性
    //1.静态资源 不能调用非静态资源  ==》非静态资源可以调用静态资源
    //2.静态资源可以通过类名直接调用  也可以继续使用对象调用  Math.PI   Arrays.sort()  
    //3.静态属性 所有对象共享     ==》存储在方法区的元数据区中
    //4.静态方法 静态代码块 内部不能使用this  ==》因为静态方法有可能使用类名直接调用 没有对象
​
/*
     * static 修饰属性
     *  1.依然可以使用对象调用 增加了使用类名调用
     *  2.静态属性 所有对象 以及类名共用 存储在方法区中的元数据区内
     * 
     * static 修饰方法
     *  1.依然可以使用对象调用 增加了使用类名调用
     *  2.静态方法中 不可以使用this
     * 
     * static 修饰代码块
     *  1.加载就执行 不受调用
     *  2.内部不能使用this
     *  3.只能调用在其前面声明的静态属性
     * 
     * 静态资源 不能调用非静态资源==》非静态资源可以调用静态资源
     * 静态资源加载 从上向下  
     */

public class Pet{
    String petName;
    int petAge;
}
​
public class Student{
    String name;
    int age;
    Pet pet;
}
​
public class Impl{
  
    public Student getStu(){
        Student s = new Student();
        return s;
        //return new Student();
    }
  
    public Pet getPet(){
        int i = 10;
        if(i==10){
            return new Pet(); 
        }
        //return null;//兜底 让虚拟机认为每种情况都有返回值 其实这里执行不到
    }
  
}
​
//测试类中
    Student s0 = new Student();
    s0.name = new String("张三");
    s0.age = 18;
    s0.pet = new Pet();
    s0.pet.petName = "豆豆";
    s0.pet.petAge = 1;
​
    Student[] ss = new Student[3];
    ss[0] = new Student();
    ss[0].name = "李四";
    ss[0].age = 20;
    ss[0].pet = new Pet();
    ss[0].pet.petName = "花花";
    ss[0].pet.petAge = 2;
​
=============================================
​
    Pet[] pp = new Pet[3];
    pp[0] = new Pet("aa",1);
    pp[1] = new Pet("",2);
    pp[2] = new Pet("",1);
​
    ss[0].pet = pp[0];
​
​
​
public int[] getNums(){
    int[] n = new int[]{1,3,4};
    return n;
}
​
public int getNum(){
    int i = 5;
    if(i==5){
        return 3;
    }else if(i!=5){
        return 7;//虽然这个else不会执行 但是必须保证方法的任何情况都有返回值
    }
    return 0;
}
​
public boolean getBool(){
    return true;
}
​
//接收带返回值的方法
//方法 调用一次 就会执行一次
    int l = xx.getNum();
    syso(xx.getNum());
    int n = xx.getNum()+5;
    if(xx.getBool()){
​
    }
​
int sel = input.nextInt();
if(sel==1){
  
}else if(sel==2){
  
}else{
  
}
​
syso(Arrays.toString(数组名));

1.形参属于局部变量 但是没有值 直接参与编写方法体
2.如果传递的是引用数据类型 则传递的是地址  导致  实参与形参共享空间
3.实参要与形参一一对应的传递 尤其注意含义
  
同一个代码块中  使用变量名来区分变量===》声明的变量名相同 就是相同变量 会报错
而方法的区分  1.方法名不同 肯定是不同方法   2.形参参数列表

public class Impl{
  
    public void getNums(int num){//编写方法时 创建形参
        int[] nums = new int[num];  //将形参 当成已知量 编写方法体
    }
  
}
​
//测试类中
    Impl impl = new Impl();
    syso("请输入数组长度");
    int n = input.nextInt();
    impl.getNums(n);    //调用带参方法时 将准备好的数据（实参）一一对应传入

    public void getFruit(int l,String name,int i){
        syso("总共"+l+"杯"+name+"汁分给"+i+"个人喝");
    }
​
    //调用方法
    syso("几杯");
    int b = input.nextInt();
    syso("什么水果");
    String n = input.next();
    syso("几人用餐");
    int p = input.nextInt();
​
    xx.getFruit(b,n,p);
​
    public void getFruit(int l,String n){
        syso("我是方法重载");
    }

public class User{
    String name;
    int age;

    public String toString(){
        return name+" "+age;
    }
}


public class Impl{

    public void m1(int n){
		n+=5;
        syso(n);	//
    }


    public void m2(User u){
        //u接收的是测试类中uu1的地址 
        //u = new User();
        u.name = "老妖精";
        u.age = 100;
        syso(u);	//老妖精 100
    }

    public User getUser(String name){
        for(User u : us){//增强for循环 赋给u的就是一个元素的地址
            if(u.getName().equals(name)){
                return u;//返回地址
            }
        }
        return null;//地址
    }
}


//测试类
	Impl u = new Impl();

	int nn = 10;
	u.m1(nn);	//15
	syso(nn);	//10

	User uu1 = new User();
	uu1.name = "张三";
	uu1.age = 18;
	syso(uu1);	//张三 18
	u.m2(uu1);	//老妖精 100
	syso(uu1);	//老妖精 100



	User uu = u.getUser("老妖精");//地址传递

	if(uu==null){
        syso("不存在");
    }else{
        uu.name = "老妖精";
    }

public class User{
    public String name;
    public int age;
    public double score;

    public User(){
        syso("我是空参构造");
    }

    //一旦编写有 带参构造方法 默认隐式空参构造就会失效
    public User(String name,int age){
        this();
        this.name = name;
        this.age = age;
    }

    public User(String name,int age, double score){
        //this(name,age);	//必须是该构造方法的第一句话
        this.name = name;
        this.age = age;
        this.score = score;
    }
}

//测试类中
	User u = new User();//报错	默认隐式空参构造 因为带参构造的出现 而失效

	syso("请输入姓名");
	String name = input.next();
	syso("请输入年龄");
	int age = input.nextInt();
	syso("请输入积分");
	double score = input.nextDouble();

	u.name = name;
	u.age = age;
	u.score = score;

	User u = new User(name,age,score);

public class Pet{

}
public class Dog extends Pet{

}
//测试类Test
public class Test{
	{

	}
	public Test(){

	}
	main(){

        Dog d = new Dog();

        //Test t = new Test(); 如果没有创建测试类对象 则不执行测试类构造代码块 构造方法
        //如果创建了测试类对象 就要看顺序
    }
}