java面向对象初始与值传递

java的面相对象感觉很有活力比python那种简便化的面相对象有趣多了，何谓面相对象什么是面向对象，这个话题一直是很多人和面试官会去深究的问题，，

面向对象思想是将人们在现实生活中的事物应用到程序设计中。对象就是现实生活中真实存在的，比如某个人某个事物这都是可以叫做一个对象

类：

  将具有相同属性及相同行为的一组对象称为类。广义地讲，具有共同性质的事物
的集合就称为类。
eg：一匹马是一个类。而马就是对象。类可以理解为这个对象中的一个实例而对象是一个大的泛指

面向对象的程序设计有三个主要特征，如下:

封装性 继承性 多态性

首先先创建一个简单的类和对象

public class clas {

    public static void main(String[] args) {
        // 首先想要调用类中的信息要先是实例化一个对象类操作

        Person p1 = new Person();
        //然后通过对象给类中的信息赋值
        p1.name = "隔壁老王";
        p1.age = 17;
        p1.talk();   // 我是隔壁老王今年：17
    }
}

class Person{ //类
    String name;  //属性
    int age;
    boolean isMarried;
    public void walk(){ // 方法
        System.out.println("人走路");
    }
    public void eat(){
        System.out.println("人能吃");
    }
    void talk(){
        System.out.println("我是"+name+"今年："+age);
    }
}

类中的方法是通过void来进行实现的。和python的def差不多

创建对象语法: 类名 对象名 = new 类名();

创建类中的方法一般需要加上void ： void 方法名(){方法体}

注意：在整个java项目（java文件）中不可以出现相同的类，因为java在编译的时候上面的类编译之后 再识别出相同的就会报错，或者在倒入的时候也会导致识别出错

一个类可以有多个对象，实例化的对象的空间每一个都在内存中单独开辟一块空间互不干扰

如果类中有私有属性 private装饰的就不能直接调用或者赋值了不然就会报错

成员变量存储在堆中 是需要垃圾回收机制来处理，局部变量存储在栈中随着方法的结束而释放

练习：

编写教师类和学生类，并通过测试类创建对象进行测试
Student类
属性:
name:String age:int major:String interests:String
方法:say() 返回学生的个人信息
Teacher类
属性:
name:String age:int teachAge:int course:String
方法:say() 输出教师的个人信息

eg：

public class cls {
    public static void main(String[] args) {
        teacher te = new teacher();
        te.name = "王老师";
        te.age = 17;

        stu st = new stu();
        st.name = "小明";
        st.age = 16;
        te.say(st.name,st.age);
        st.say(te.name, te.age);
    }
}

class teacher{  //  老师类
    String name;
    int age;
    String major;
    String interests;
    void say(String name, int age){
        System.out.println("这个学生是："+name+"年龄是："+age);
    }

}

class stu{ // 学生类
    String name;
    int age;
    int teacherAge;
    String course;
    void say(String name, int age){
        System.out.println("这个老师是："+name+"年龄是："+age);
    }
}

方法的声明：

权限修饰符  返回值类型  方法名(形参列表){
                 方法体
          }

方法名：属于标识符，遵循标识符的规则和规范，“见名知意”


注意：我们再传递参数的时候也一定要把参数的类型传递进去不然会报错
    public void addAge(int age){ // 传递参数把参数age的类型int也传递进去
        age +=2;
    }

return ：java中的return和python的return是一样的。都是返回结果 然后终止方法

方法可以分为void不带返回值的方法 和携带返回值的方法

class  te{
    String name;  // 成员变量
    int age;
    String major;

    void sys(){  // void不需要返回值
        int age;
    }

    public String getName(){
        return name;  // 因为方法体是没有void的就需要return来进行返回了
    }
}

注意：

在方法中可以调用方法：递归调用
但是不可以在方法中定义方法

 练习：

1、

编写程序，声明一个method方法，在方法中打印一个10*8 的*型矩形，在main方法中调用该方法

public class Usertest {
    public static void main(String[] args) {
        Usertest user = new Usertest();
        user.method();

    }


    public void method(){
        for(int i = 0; i < 10; i++ ){
            for(int j = 0; j < 8; j++){
                System.out.print("*");

            }
            System.out.println();
        }

    }
}

2、

修改上一个程序，在method方法中，除打印一个10*8的*型矩形外，再计算该矩形的面积，
 * 并将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印。

public class Usertest {
    public static void main(String[] args) {
        Usertest user = new Usertest();

        int aray = user.method();
        System.out.println("矩形的面积是："+aray);

    }

    public int  method(){
        for(int i = 0; i < 10; i++ ){
            for(int j = 0; j < 8; j++){
                System.out.print("*");

            }
            System.out.println();
        }
        return 10*8;  // 想要返回值就要把上面的方法定义为要放回值的类型
    }
}

3、

修改上一个程序，在method方法提供m和n两个参数，方法中打印一个m*n的*型矩形，
 * 并计算该矩形的面积， 将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印。

public class Usertest {
    public static void main(String[] args) {
        Usertest user = new Usertest();

        int aray = user.method(10,5);   // 给参数
        System.out.println("矩形的面积是："+aray);

    }

    public int  method(int m, int n){  // 传递参数
        for(int i = 0; i < m; i++ ){
            for(int j = 0; j < n; j++){
                System.out.print("*");

            }
            System.out.println();
        }
        return 10*8;  // 想要返回值就要把上面的方法定义为要放回值的类型
    }
}

对象数组题目

对象数组题目: 定义类Student，包含三个属性:学号number(int)，年级state(int)，成绩 score(int)。 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。 
问题一:打印出3年级(state值为3)的学生信息。
问题二:使用冒泡排序按学生成绩排序，并遍历所有学生信息
提示:
1) 生成随机数:Math.random()，返回值类型double;
2) 四舍五入取整:Math.round(double d)，返回值类型long。
5.声明一个日期类型MyDate:有属性:年year,月month，日day。创建2个日期 对象，分别赋值为:你的出生日期，你对象的出生日期，并显示信息。

第一种：

public class Usertest{
    public static void main(String[] args) {
        Stude [] stu = new Stude [20]; // 生成一个对象数组规定长度为20 因为要生成20个不能一个一个生成吧
        for(int i = 0; i < stu.length; i++){
            stu[i] = new Stude (); // 生成每一个对象的数组

            // 给每一个对象属性赋值
            stu[i].number = (i+1);

            //年纪[1, 6]
            stu[i].state = (int)(Math.random()*(6-1+1)+1);
            stu[i].score = (int)(Math.random()*(100-0-1)+1);
        }

        // 遍历学生数组
        for(int i = 0; i < stu.length; i++){
//            System.out.println(stu[i].number+","+stu[i].state+","+stu[i].score);
            System.out.println(stu[i].info());
        }

        System.out.println();

        // 求出三年级学生的的学生信息
        System.out.println("这是三年级学生的信息");
        for(int i = 0; i < stu.length; i++){
            if(stu[i].state == 3){

                System.out.println(stu[i].info());
            }

        }
        System.out.println("=========");

        // 使用冒泡排序对学生的成绩排序

        for(int i = 0; i < stu.length;i++){
            for(int j = 0; j < stu.length -i -1; j++){
                if(stu[j].score > stu[j+1].score){  // 两个值的转换必须要定义一个第三方数字不能像python一直直接交换
                    Stude tmp = stu[j];  // 参数的定义也要是对象数组的元素
                    stu[j] = stu[j+1];
                    stu[j+1] = stu[j];
                }
            }
        }
        for(int i = 0; i < stu.length; i++){
//            System.out.println(stu[i].number+","+stu[i].state+","+stu[i].score);
            System.out.println(stu[i].info());
        }

    }
    static class  Stude{   // 因为主类是static的  如果写在了公类里面 也要是static，除非是放在公类外部
        int number = 0; // 学号
        int state = 0; // 年纪
        int score = 0; //  成绩

        String info(){
            return "学号："+number+" 年纪: "+state+" 成绩: "+score;
        }
    }
}

 第二种面向对象的额封装：

public class Usertestplus {
    public static void main(String[] args) {
        Student [] stu = new Student[20];
        for(int i = 0; i < stu.length; i++){
            stu[i] = new Student();  // 实例化每一个对象

            //为每一个对象的信息进行赋值
            stu[i].number = i+1;
            stu[i].state = (int)(Math.random()*(6-1+1)+1);
            stu[i].score = (int)(Math.random()*(100 -0 +1)+1);
        }


        // 因为方法是在公共类中的  需要公共类的对象来调用
        Usertestplus user = new Usertestplus();
        user.print(stu);


        //打印3年纪的学生的信息
        System.out.println("打印3年纪学生的信息");
        user.searchState(stu,3);


        //使用冒泡排序来进行信息排序
        System.out.println("使用冒泡进行排序");
        user.sort(stu);

        // 对排序后的 信息进行遍历

        user.print(stu);

    }


    // 遍历信息

    static void print(Student[] stu){  // 把定义的类数组给传递进来
        for(int i = 0; i < stu.length; i++){
            System.out.println(stu[i].info());

        }
    }

    //查找 3年纪的学生的信息
    static void searchState(Student [] stu, int state){
        for(int i = 0 ;i < stu.length; i++){
            if(stu[i].state == state){
                System.out.println(stu[i].info());
            }
        }
    }

    //排序
    static void sort(Student [] stu){
        for(int i = 0; i<stu.length; i++){
            for(int j = 0; j < stu.length-i-1; j++){
                if(stu[j].score > stu[j+1].score){
                    Student tmp = stu[j];
                    stu[j]= stu[j+1];
                    stu[j+1] = tmp;
                }

            }

        }


    }

}




class Student{
    int number; //学号
    int state; // 年纪
    int score; // 成绩

    public String info(){
        return "学号："+number+" 年纪："+state+" 成绩："+score;
    }
}

对象的内存解析：

 匿名对象：

即没有对这个对象赋名。每一次使用都要new一个

        Person p1 = new Person();
        //然后通过对象给类中的信息赋值
        p1.name = "隔壁老王";
        p1.age = 17;
        p1.talk();   // 我是隔壁老王今年：17
        
        //上面是创建了有名对象每次使用都通过这个对象名去调用
        // 匿名对象：
        new Person().age=16; // 通过匿名对象去调用
        new Person().name = "老李";// 这两个匿名对象是不同的 

每一次创建的匿名对象是不同的：

public class clas {

    public static void main(String[] args) {
        // 首先想要调用类中的信息要先是实例化一个对象类操作

        Person p1 = new Person();
        //然后通过对象给类中的信息赋值
        p1.name = "隔壁老王";
        p1.age = 17;
        p1.talk();   // 我是隔壁老王今年：17

        //上面是创建了有名对象每次使用都通过这个对象名去调用
        // 匿名对象：
        new Person().age=16; // 通过匿名对象去调用
        new Person().name = "老李";// 这两个匿名对象是不同的
        new Person().talk(); //   我是null今年：0  这里的值是都不同的  所以对象都是不同的


    }
}

class Person{
    String name;
    int age;
    boolean isMarried;
    public void walk(){
        System.out.println("人走路");
    }
    public void eat(){
        System.out.println("人能吃");
    }
    void talk(){
        System.out.println("我是"+name+"今年："+age);

    }
}

 方法的重载：即一个类中可以出现多个名字相同的方法 只要参数的个数或者类型不同即可，甚至两个参数的位置不同的 时候也会认为是两个不同的方法

    String name;
    int age;
    boolean isMarried;
    public void walk(){
        System.out.println("人走路");
    }
    public void eat(){
        System.out.println("人能吃");
    }
    
    //如下的两个方法构成了方法的重载
    void talk(){
        System.out.println("我是"+name+"今年："+age);

    }

    void talk(int age){
        System.out.println(age);
    }
}

判断是否是重载：

跟方法的权限修饰符、返回值类型、行参变量名、方法体都没有关系

习题：判断是否是重载

与void show(int a,char b,double c){}构成重载的有: 
a) void show(int x,char y,double z){} // no
b) int show(int a,double c,char b){} // yes
c) void show(int a,double c,char b){} // yes
d) boolean show(int c,char b){} // yes
e) void show(double c){} // yes
f) double show(int x,char y,double z){} // no 
g) void shows(){double c} // no

练习：

编写程序，定义三个重载方法并调用。方法名为mOL。 三个方法分别接收一个int参数、两个int参数、一个字符串参数。分别
执行平方运算并输出结果，相乘并输出结果，输出字符串信息。 在主类的main ()方法中分别用参数区别调用三个方法。
3.定义三个重载方法max()，第一个方法求两个int值中的最大值，第二个方 法求两个double值中的最大值，第三个方法求三个double值中的最大值， 并分别调用三个方法

public class clas {

    public static void main(String[] args) {
        // 首先想要调用类中的信息要先是实例化一个对象类操作

        Person p1 = new Person();
        //然后通过对象给类中的信息赋值
        p1.name = "隔壁老王";
        p1.age = 17;
        p1.talk();   // 我是隔壁老王今年：17

        //上面是创建了有名对象每次使用都通过这个对象名去调用
        // 匿名对象：
        new Person().age=16; // 通过匿名对象去调用
        new Person().name = "老李";// 这两个匿名对象是不同的
        new Person().talk(); //   我是null今年：0  这里的值是都不同的  所以对象都是不同的


        // 
        System.out.println(p1.mOl(3));  // 9
        System.out.println(p1.mOl(3,6));  // 18
        System.out.println(p1.mOl("lao"));  // 这个是：lao

        System.out.println(p1.max(3,7));  //7
        System.out.println(p1.max(3.2,5.64));  //5。64


    }
}

class Person{
    String name;
    int age;
    boolean isMarried;
    public void walk(){
        System.out.println("人走路");
    }
    public void eat(){
        System.out.println("人能吃");
    }

    //如下的两个方法构成了方法的重载
    void talk(){
        System.out.println("我是"+name+"今年："+age);

    }

    void talk(int age){
        System.out.println(age);
    }


    int mOl(int num){
        return num*num;
    }

    int mOl(int num, int number){
        return num*number;
    }
    String mOl(String str){
        return "这个是："+str;
    }

    int max(int num, int number){
        int max = (num > number)? num :number;
        return max;

    }

    double max(double num, double number){
        double max =(num > number)? num :number;
        return max;

    }
}

 可变形参：

可变行参的格式：　　数据类型....变量名

oublic vold nick(String .... name){  // 可以给nick这个方法传递无限多个的字符串类型的参数


}

当调用可变个数行参的方法时，传入的参数可以是0个1个或者多个

 变量的赋值：

如果变量是基本数据类型，此时赋值的变量是变量所保存的数据值

如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值

如果参数是基本数据类型，此时实参赋值给形参的是实参的真实的数据值
　　

参数的赋予的时候地址的转换：

两个参数的值的赋予：普通数据类型在赋值的时候是只有一个栈空间的。把值在copy一份给另一个参数的。引用数据类型的值的赋予时候是堆空间都指向同一个 只有栈空间的名字不同，所以当一个改变的时候会带动堆空间的值的改变那就是都改变了

引用数据类型赋值

基础数据和引用数据在值的交换的注意

public class swap {
    public static void main(String[] args) {
        swap sw = new swap();  // 创造公共类对象
        swp s = new swp();
        s.m =19;
        s.n=6;
        s.swap(s.m,s.n);
        System.out.println("m: "+s.m+"n:"+s.n);  // m :19 , n:6   大家思考下为什么没有换成呢？ 因为 你这个m的值和下面的方法中的值是两个了   因为此时的m和n是基础数据类型在栈中有不同的位置 方法中换了
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　但是最初定义的没有换


        sw.swap(s);  // 因为方法定义在公共类中只能通过公共类来调用

        System.out.println("m: "+s.m+"n:"+s.n); //m: 6n:19 因为引用数据类型的值指向的都是一样的所以可以交换成功


    }
    
    public void swap(swp s){  //使用引用数据类型来当行参
        int tmp = s.m;
        s.m = s.n;
        s.n = tmp;
    }
}


class  swp{
    int m;
    int n;
    public void swap(int m, int n){
        int tmp = m;
        m = n;
        n = tmp;

    }
}

行参是方法定义时，声明在小括号内的参数

实参：方法调用时，实际传递给行参的数据

例题

public class AprilThreeAfternoonTestOne {
    public static void main(String[] args) {
        AprilThreeAfternoonTestOne aprilThreeAfternoonTestOne = new AprilThreeAfternoonTestOne();
        aprilThreeAfternoonTestOne.first();
    }
    
    public void first(){
        int i = 5;
        AprilThreeAfternoon aprilThreeAfternoon = new AprilThreeAfternoon();
        aprilThreeAfternoon.i = 25;
        second(aprilThreeAfternoon,i);
        System.out.println(aprilThreeAfternoon.i);

    }
    
    public void second(AprilThreeAfternoon aprilThreeAfternoon, int i){
        i = 0;
        aprilThreeAfternoon.i = 20;
        AprilThreeAfternoon af = new AprilThreeAfternoon();
        aprilThreeAfternoon = af;
        System.out.println(aprilThreeAfternoon.i +" "+ i );
    }
}


class AprilThreeAfternoon{
    int i = 15;
}

15 0
20

20 是因为在second结束之后就释放了所覆盖的所以又回到了以前所赋值的

面试题：

定义一个int型的数组:int[] arr = new int[]{12,3,3,34,56,77,432}; 让数组的每个位置上的值去除以首位置的元素，得到的结果，作为该位置上的 新值。遍历新的数组

答案：

//错误写法   
for(int i= 0;i < arr.length;i++){  因为这样就会把除去的数字当作第一位数字了
arr[i] = arr[i] / arr[0]; }


//正确写法1
for(int i = arr.length – 1;i >= 0;i--){
arr[i] = arr[i] / arr[0]; }
//正确写法2
int temp = arr[0];
for(int i= 0;i < arr.length;i++){
arr[i] = arr[i] / temp; }

 计算1-100直接所有自然数的和：

    public static void main(String[] args) {
        jia ji = new jia();
        System.out.println(ji.sum(100));

    }
    public int sum(int num){
        if(num == 1){
            return 1;
        }else {
            return num+sum(num-1);
        }

    }
}