JavaSE| 面向对象

System.out.println(new Circle()); //new Circle()匿名对象  -->>  Circle@15db9742
        
        Circle c1 = new Circle();  //有名对象，它的名字就是c，c是对象名
        c1.circle = 1.2;
        
        String name = "kris";//String也是类名,name是对象名，"张三"是一个字符串的对象
        if(name.equals("kris")){
            
        }
        
        //创建了一个java.util.Scanner的对象
        //java.util.Scanner也是一种类，也是数据类型
        java.util.Scanner input = new java.util.Scanner(System.in);
        //input是对象名
        int num = input.nextInt();
        
        int[] arr = new int[5];//创建了一个数组对象，数组的元素相当于数组的成员变量，属性
        //int[]    -->>数组类型 <<-->>引用数据类型  -->>默认为null
        //int[][] -->>int类型为基本数据类型  -->>默认为0

class TestCircle{
    public static void main(String[] args){
        
        Circle c1 = new Circle(); //创建了一个圆对象
        
        c1.radius = 2.1; //为属性赋值；
        
        System.out.println(c1.radius);
        System.out.println(c1.getArea());
        System.out.println(c1.getLength());   
    }
}

/*
1、声明一个类
2、用类来创建具体的对象
*/
class Circle{
    double radius;
    
    double getArea(){
        return Math.PI * radius * radius;
    }
    double getLength(){
        return 2 * Math.PI * radius;
    }

}

class TestMethod2{
    public static void main(String[] args){
        
        printJiuJiu();//无参无返回值
        
        printRectangle(5,5,‘*‘); //有参无返回值
        
        System.out.println(getNum()); //有参无返回值
        
        int max = getMaxNum(7,9);
        System.out.println("最大值为:" + max);
        
        System.out.println("三个数最大值为:" + getThreeNum(5,9,12));
    }



    public static void printJiuJiu(){  //无参无返回值
        for(int i = 1;i <= 9;i++){
            for(int j = 1;j < i;j++){
                System.out.print(j + "*" + i + "=" + j*i + "\t");
            }System.out.println();
        }
    }

    public static void printRectangle(int m, int n, char x){ //有参无返回值
        //第一轮:i=1, j=1,2,3,4,5,6循环6次;
        for(int i = 1;i <= m; i++ ){ 
            for(int j = 1; j <= n; j++ ){ 
                System.out.print(x);
                
            }System.out.println(x);
        }
    }
    
    public static int getNum(){  //无参有返回值
        int num = (int)(Math.random() * 100);
        return num;
        
    }
    
    public static int getMaxNum(int a,int b){ //有参有返回值
            
        if(a > b){
            return a;
        }else{
            return b;
        }
    }
    
    public static int getThreeNum(int a, int b, int c){
        
        int max = getMaxNum(a, b);
        max = getMaxNum(c, max);
        return max;
    }
    
}

class TestMethod{
    public static void main(String[] args){
        
        System.out.println("数组为:");
        int[] arr = {3,6,2,9,0,8,4,5};
        printShuZu(arr);
        for(int i = 0;i < arr.length; i++){
            System.out.print(arr[i] + "\t");
        }
        
        //System.out.println(printSum(1,100));
        
        System.out.println("阶乘为:");
        System.out.println(printJieCheng(10));
    }

    
    //声明一个方法，可以为所有的int[]数组实现从小到大排序
    //冒泡排序； 有参数没有返回值
    public static void printShuZu(int[] arr){
        //数组,长度为8,排序
        // 第一次 i=1,j=0,1,2,3,4,5,6;
        for(int i = 1;i < arr.length; i++){
            for(int j = 0;j < arr.length - i; j++){
                if(arr[j] > arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }

    //声明一个方法，可以累加[m,n]之间的和
    //有参数有返回值的；
    public static int printSum(int m , int n){
        
        int sum = 0;
        for(int i = m;i<=n; i++){
            sum += i;
        } return sum;
    }
    
    //（3）声明一个方法，可以实现求任意正整数的阶乘
    public static int printJieCheng(int m){
        
        int jieCheng = 1;
        for(int i = 1;i < m; i++){
             jieCheng *= i;
        }
        return jieCheng;
        
    }
    
    

}

{
        public static void main(String[] args) {
        int i = 0;
        change(i);//i=0，调用change函数,完成之后，它在内存中就会撤掉；主方法和change方法是两个独立的内存。
        System.out.println("调用方法后" + i); //i=0
        i = i++; //i=0,先把他load到操作栈里边，i再自增i=1,再把操作栈里的值赋值给i；
        //System.out.println(i++); //如果运行这一步,输出0，则下面输出i=1
        System.out.println("i = " + i); //i=0
        }
        public static void change(int i){
            i++;
            System.out.println(i); //i=1
        }    
}

class TestPassValue{
    public static void main(String[] args){
        toDouble1(3);
        
        MyDate d = new MyDate();  //把变量MyDate d放到栈里边，一个单独的内存空间,会有一个地址值如0x666； 而new产生对象是放在堆里边的,x默认为0，把它改成3；
        d.x = 3;
        toDouble2(d);　　　　　　//主方法和自己定义的方法是两个独立的内存空间，但有一个相同的地址值，通过myCanShu找到堆里边的x，把它改成原来的3倍大，执行完后撤走。
        //System.out.println(d.x); 
        
        int[] array = {3,2,5,9,1,4,0};
        sort(array);//array实参把数组的首地址给形参arr，意味着arr和array指向同一个数组，对arr的排序就是对array的排序。
        //发现可以实现排序
        
        
        String s = "I Love";  //虽然没有new关键字，但它还是对象，它不是存在栈里边，在常量池里边，value=”I Love”，字符串的对象
        change(s);    //实参s把地址值给了形参String str = s；但String对象是不可变的，一旦改变如拼接、截取等，就会产生一个新的字符串对象。--> value=I LoveChina
        System.out.println("s = "  + s);  //产生新对象之后，原来的value=I Love就不要了，自己定义的方法执行完就会撤离，这时候你原来在主方法中的s=I Love还是在的。
    }　　　　　　　　　　　　　　　　　　　　　　　　//产生的是新对象，跟原来的没有关系，这是个陷阱。
    
    public static void toDouble1(double num1){  //形参为基本数据类型时,形参的改变不会影响到实参
        
        
        System.out.println(num1);
        num1 *= 2;
        System.out.println(num1);    
        
    }
    
    public static void toDouble2(MyDate myCanShu){  //形参为引用数据类型时,形参修改了它的属性，实参也要改变。
        
        System.out.println(myCanShu.x);
        
        myCanShu.x *= 3;　　//变量MyDate myCanShu，会有一个地址值0x666,这个方法单独开一个内存空间，隐含了一个MyDate myCanShu = d ;
        
        System.out.println(myCanShu.x);
    }
    //定义一个对数组排序的方法
    //假如是有3个元素的数组
    //i=1, j=0,1
    //i=2, j=0
    public static void sort(int[] arr){ //形参为数组(数据类型+变量名)
        //foreach循环
        for(int num : arr){
            System.out.print(num);
        }
        
        for(int i = 1; i < arr.length; i++){
            for(int j = 0; j < arr.length-i; j++){
                if(arr[j] > arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];;
                    arr[j+1] = temp;
                }
            }
        }
        System.out.println();
        for(int num : arr){
            System.out.print(num);
        }
    }
    public static void change(String str){  //形参为String引用数据类型时
        //特殊情况：如果形参是String，Integer等不可变对象时，那么无论怎么修改形参都和实参无关的。
        //因为形参已经指向新的对象。
        System.out.println();
        str += "China";
        System.out.println(str);
        
    }
}

class MyDate{
    
    int x;
}

/*声明一个圆类，有属性：半径radius
给圆类增加成员方法：
(1)求圆的面积的方法
*/
class Circle{
    double radius;
    
    //(1)求圆的面积的方法; 返回值：面积
    //形参：是否需要？这里不需要，因为对象中已经有半径值
    double getArea(){
        double area = Math.PI * radius * radius;
        return area;
    }
    
    double getPerimeter(){
        return 2 * Math.PI * radius;
    }
    
    String getInfo(){
        return "圆的半径是：" + radius + "，它的面积是：" + getArea() + "，它的周长：" + getPerimeter();
    }
}
class TestCircle{
    
    public static void main(String[] args){
        //(1)先创建圆对象
        Circle c1 = new Circle();
        
        //(2)求面积，求哪个圆的面积
        double d = c1.getArea();
        System.out.println("面积：" + d);
        
        //(3)设置半径的值
        c1.radius = 2.5;
        d = c1.getArea();
        System.out.println("面积：" + d);
        System.out.println("周长：" + c1.getPerimeter());
        System.out.println(c1.getInfo());
    }
}

/*
命令行参数：（了解）
    给main()传递的实参，称为命令行参数
如果要给main()的形参传值，可以用如下的格式：
    java 类名  实参1 实参2 实参3...

参数：
    形参
    实参
    命令行参数
    
*/
class TestCommandParam{
    //public static是修饰符
    //void：表示main没有返回值
    //main：方法名
    //String[] args：形参
    public static void main(String[] args){
        System.out.println("参数的个数：" + args.length); //参数的个数：0
        for(int i=0; i<args.length; i++){
            System.out.println(args[i]); 
        }
    }
}

package day05;
/*1.面向对象的编程关注类的设计
 * 2.设计类实际上就是设计类的成员
 * 3.基本的类的成员：属性（成员变量或Field） & 方法（Method）
 */
import java.util.Scanner;
public class TestPerson {
    public static void main(String[] ages){
        Person p1 = new Person();
        p1.info();  //这一步调用的时候还没赋值，打印出来的都是默认的
        
        p1.name = "alex";
        p1.age = 22;
        p1.sex = true; //只能取true或false
        p1.info(); //这一步就赋值了，把默认值修改了；   通过p1.属性的方法修改
//        
        p1.setName("kris"); //p1.name = "kris"; 这两种是一样的。 通过p1.方法进行修改，这个“kris”传给了n又给了name
        p1.info();           //把属性的赋值过程相当于封装到了方法里边
//        
        Person p2 = p1;
        System.out.println("p1:" + p1);
        System.out.println("p2:" + p2); //这两个肯定是一样的，p1赋值给了p2，地址一样
        p2.info();
//        
        p2 = new Person();  //这个时候p2的地址值就变了
        System.out.println("p2:" + p2); 
        p2.info();
//        
        //实例化Scanner类的对象，通过此对象.nextXxx()调用，完成相应的功能。
        Scanner s = new Scanner(System.in);
        int i = s.nextInt();
        
    }
}
//类是抽象的
class Person{
    //1.属性：
    String name;
    int age;
    boolean sex;
    
    //2.方法
    public void eat(){
        System.out.println("人吃饭");
    }
    public void sleep(){
        System.out.println("人睡觉");
    }
    public String getName(){ //获取名字
        return name;
    }
    
    //给属性name赋值的过程
    public void setName(String n){ //可修改名字，调用这个方法的时候传一个n进来赋给name
        name = n;
    }
    public void info(){
        eat();
        sleep();
        System.out.println("name:" + name + "age:" + age + "sex:" + sex);
    }
    
}

package day05;
/*一、面向对象思想的落地法则一
 * 1.设计类，并设计类的成员（成员变量&成员方法）
 * 2.通过类，来创建类的对象（也称作类的实例化）
 * 3.通过“对象.属性” 或 “对象.方法”来调用，完成相应的功能
 * 
 * 二、创建的多个对象，彼此各拥有一套类的属性。当对其中一个类的对象进行修改时，
 * 不会影响到其他对象的属性值。
 * 
 * 三、类的属性（成员变量）
 * 成员变量 vs 局部变量
 * 相同点：1.遵循变量声明的格式：数据类型  变量名 = 初始值
 *          2.都有作用域
 * 不同点：1.声明的位置的不同：成员变量：声明在类里边，方法外
 *                          局部变量：声明在方法内，方法的形参部分，代码块内
 *          2.成员变量的修饰符有四个：public private protected 缺省
 *           局部变量没有修饰符，与所在的方法修饰符相同。
 *          3.初始化值：一定会有初始化值。
 *           成员变量：如果在声明的时候，不显示的赋值，那么不同数据类型会有不同的默认初始值。
 *             byte  short  int  long ===>>0
 *             float double  ===>> 0.0
 *             char ===>空格
 *             boolean ==> false
 *             引用类型变量 ==> null
 *         局部变量：一定要显式的赋值。（局部变量没有默认初始值）
 *         4.二者在内存中存放的位置不同：成员变量存在于堆空间中；局部变量：栈空间中
 * 总结：
 * 关于变量的分类：1）按照数据类型的不同：基本数据类型（8种） & 引用数据类型
 *                2）按照声明的位置不同：成员变量 & 局部变量
 * 
 * 四：方法
 *         1）实例：public void eat(){//方法体}
 *                public String getName(){}
 *                public void setName(String n){}
 *           格式：权限修饰符  返回值类型（void:无返回值/具体的返回值） 方法名（形参）{}
 *         2）关于返回值类型：void：表明次方法不需要返回值
 *             有返回值的方法：在方法的最后一定要有return + 返回值类型对应的变量
 *             记忆：void与return不可以同时出现一个方法内，像一对“冤家”
 *         3）方法内可以调用本类的其他方法或属性，但是不能在方法内在定义方法！
 * 
 */
public class Zoo {
    public static void main(String[] args){
        //基本数据类型的声明：数据类型  变量名 = 初始化值
        int i = 10;
        //类的实例化：如下的a1就是一个实实在在的对象
        Animal a1 = new Animal();
        //int[] arr = new int[10];
        //通过对象调用属性
        a1.name = "kris";
        a1.age = 3;
        System.out.println("name:" + a1.name + "age:" + a1.age); //name:krisage:3
        //通过对象调用方法
        a1.eat(); //动物进食
        a1.sleep(); //动物休眠
        
        //再创建一个类的对象
        Animal a2 = new Animal();
        System.out.println("name:" + a2.name + " age:" + a2.age ); //name:null age:0
        a2.name = "小花";
        System.out.println("name:" + a1.name + " age:" + a1.age); //name:kris age:3
        System.out.println("name:" + a2.name + " age:" + a2.age); //name:小花 age:0
        
        //a3不意味着相较于a1重新创建的一个对象，而是a1与a3共同一个对象的实体。
        Animal a3 = a1;
        System.out.println("name:" + a3.name + " age:" + a3.age);//与a1一样 name:kris age:3
        a3.name = "小熊熊";
        System.out.println("name:" + a1.name + " age:" + a1.age); //name:小熊熊 age:3
        
        System.out.println(a2.getName()); //a2.name;
        System.out.println(a2.desc());
    }
}

class Animal{
    //1.属性
    String name;
    int age;
    
    //2.方法
    public void eat(){
        System.out.println("动物进食");
    }
    public void sleep(){
        System.out.println("动物休眠");
    }
    public String getName(){
        return name;
    }
    public int getAge(){
        return age; //它后边不能声明语句了如System.out.println("hello");
    }
    //当通过对象调用此方法时，会将方法的方法的返回值提供给方法的调用者，也就是当前的对象。
    public String desc(){
        if(age > 2){
            return "洽同学少年";
        }else{
            return "回去看电视吧";
        }
    }
    
    public void setName(String n){ //局部变量
        name = n;
    }
    
    public void addAge(){
        int i = 2; //局部变量
        age += i;
    }
    public void info(){
        //可以在方法内调用本类的其他方法，但是不可以在方法内定义新的方法
        eat();
        sleep();
    }
//    System.out.println("hello"); 不能在类里边单独语句输出，要输出也得在方法内
    

    
}

类的成员：
属性、方法、构造器、代码块、内部类

类的第三个成员：构造器

构造器，又称为构造方法
构造器的作用：
（1）和new一起使用时，创建对象用
（2）可以在创建对象的同时，为属性初始化，或赋初始值。

构造器的特点：
（1）所有的类都有构造器，
如果你自己没有声明，那么编译器将会自动生成一个默认的无参构造器。
如果你手动声明了构造器，那么编译器就不会再自动生成无参构造了，如果你需要无参构造，必须自己写。
（2）构造器可以重载
（3）构造器的名称必须与类名相同，并且没有返回值类型，也不写void

构造器的声明语法格式  
【修饰符】 class 类名{
    【修饰符】 类名(){
        ....
    }
    
    【修饰符】 类名(形参列表){
        ....
    }    
}
*/

this关键字：当前对象
用法：
（1）this.属性
为了解决，局部变量（例如，形参）和成员变量（例如：属性）重名时，
可以在成员变量的前面加“this.”用于区别

（2）this.方法
基本不用，但是可以这样用；表示访问当前对象的方法

（3）this()或this(实参列表)
表示访问本类的其他的构造器
要求：this()或this(实参列表)必须在构造器的首行


标准的get/set:
    public xxx的类型 getXxx(){
        return xxx;
    }
    public void setXxx(xxx的类型 xxx){
        this.xxx = xxx;
    }
    这里xxx表示属性名
构造器的标准格式：
    //无参构造
    public 类名(){
        
    }
    //有参构造
    public 类名(属性1的数据类型 属性1的名称，属性2的数据类型 属性2的名称，.。。){
        this.属性1 = 属性1;
        this.属性2 = 属性2;
        ....
    }

class TestThis{
    public static void main(String[] args){
        
        Employee emp1 = new Employee();  //无参构造创建对象
        System.out.println(emp1.getInfo());
        
        Employee emp2 = new Employee(1002,"李四"); //两个参数的创建对象
        System.out.println(emp2.getInfo());
        
        Employee emp3 = new Employee(1003,"王五",25,"1111","1245555","beijing"); //6个参数的创建对象
        System.out.println(emp3.getInfo());
    }
}

class Employee{
    private int eid;
    private String name;
    private int age;
    private String tel;
    private String cid;//身份证号
    private String address;
    
    public Employee(){
        System.out.println("一个新员工入职了！");  //不管我从下面两个哪个构造器进来，我都想执行下这句话，则在下面两个构造器下面加this()；而this(eid,name)是先
    }                                                            //去找它上边的构造器，它再去执行这句话。
    
    public Employee(int eid, String name){ //创建对象的时候我不想要这么多，比如说eid和name是员工比填的
        this();//它必须在构造器的首行
        this.eid = eid;
        this.name = name;
    }
    
    public Employee(int eid, String name, int age, String tel, String cid, String address){  //要么用无参构造，要么就要用6个参数构造
        //this.eid  = eid;
        //this.name = name;  //这两句跟前边两句是一样的
        this(eid,name);//调用自己的另一个构造器为属性赋值，//它必须在构造器的首行；；把它俩写一块，先传给eid、name，然后它再传给上边的int eid和String name;它再赋值
        this.age = age;
        this.tel = tel;
        this.cid = cid;
        this.address = address;
        
    }
    
    public String getInfo(){
        return eid + "\t" + name + "\t" + age + "\t" + tel + "\t" + cid + "\t" + address;
    }
}