Java类与对象

沐夏

于 2024-01-15 20:12:05 发布

阅读量547

点赞数 16

文章标签： java

本文链接：https://blog.csdn.net/2302_76764006/article/details/135609769

版权

package Learn1;
/*

 * 定义类：

 * 访问修饰符 class 类名{}

 * 说明：

 * 1）访问修饰符可以写成public（公共的）、默认的（什么单词都不写）

 * 2）类名要使用大驼峰命名法、做到见名知意

 * */
public class Student {
    /*

     * 定义属性：
     * 语法规则：
     * 访问修饰符 数据类型 属性名;
     * 说明：
     * 1）属性的访问修饰符有如下4个：
     * public：公共的
     * protected：受保护的
     * ：默认的，什么也不写，也不用写default
     * private：私有的
     * 2）数据类型可以是8大基本数据类型，也可以是3大引用数据类型
     * 3）属性名的命名规则与变量命名规则一样，因为你会发现，所谓的属性定义与变量定义一模一样
     * */
    public String name;
    public int age;
    public char gender;
    public double height;
    public double weight;

    /*

     * 定义方法：
     * 语法规则：
     * 访问修饰符 返回值类型 方法名([数据类型 参数名1,数据类型 参数名2,...,数据类型 参数名n]){
     * //方法体代码
     * }
     * 说明：
     * 1）方法的访问修饰符可以有如下4种：
     * public：公共的
     * protected：受保护的
     * ：默认的，什么也不写，也不用写default
     * private：私有的
     * 2）返回值类型：
     * 1）描述执行方法会得到的结果的类型，可以是8大基本数据类型，也可以是3大引用数据类型
     * 2）方法也可以没有返回值，没有返回值的时候，返回值类型写void（空）
     * 3）方法名：
     * 1）使用小驼峰命名法
     * 2）方法命名也需要做到见名知意
     * 4）[数据类型 参数名1,数据类型 参数名2,...,数据类型 参数名n]：参数列表
     * 执行这个方法需要的参数，可以没有，那么[数据类型 参数名1,数据类型 参数名2,...,数据类型 参数名n]就省略不写
     * 如果方法需要参数，就按照规则定义参数列表即可
     * 5）方法体代码：
     * 方法体代码描述的是方法要执行功能的代码
     * */
    public void printStudentInfo(){
        System.out.println("学生姓名："+name);
        System.out.println("学生年龄："+age);
        System.out.println("学生性别："+gender);
        System.out.println("学生身高："+height);
        System.out.println("学生体重："+weight);
    }

}

package Learn1;

public class StudentTest {

    public static void main(String[] args) {

        //类是一个模板，根据模板来创建对象
        //创建对象的语法规则：类名 对象名 = new 类名();
        Student student1 = new Student();
        //直接输出创建的对象
        System.out.println(student1);

        //给创建的对象的属性赋值：对象名.属性名 = 数据;
        student1.name = "张三";
        student1.age = 21;
        student1.gender = '男';
        student1.height = 180;
        student1.weight = 75;

        //通过对象调用属性：对象名.属性名

//        System.out.println(student1.name);
//        System.out.println(student1.age);
//        System.out.println(student1.weight);
//        System.out.println(student1.height);
        //通过student1对象调用方法printStudentInfo输出对象信息
        //对象名.方法名();
        student1.printStudentInfo();

        System.out.println("--------------------------");

        //创建第二个Student对象
        Student student2 = new Student();
        //给对象student2属性赋值
        student2.name = "如花";
        student2.age = 16;
        student2.gender = '男';
        student2.height = 190;
        student2.weight = 190;
        //输出student2对象的属性值

//        System.out.println(student2.name);
//        System.out.println(student2.age);
//        System.out.println(student2.gender);
//        System.out.println(student2.height);
//        System.out.println(student2.weight);
        //通过student2对象调用方法输出对象属性信息
        student2.printStudentInfo();



    }

}

package Learn2;

public class GirlFriend {
    //定义属性
    public String name;
    public int age;
    public char gender;
    public double weight;
    public double height;
    public String address;

    //定义方法
    public void printGirlFriendInfo(){
        System.out.println("姓名："+name+"，年龄："+age+"，性别："+gender+"，身高："+height+"，体重："+weight);
    }

    public void eat(){
        System.out.println("女朋友喜欢吃肉.....");
    }

    public void sleep(){
        System.out.println("女朋友一觉能睡10个小时.....");
    }

}

package Learn2;

import Learn2.GirlFriend;

public class GirlFriendTest {

    public static void main(String[] args) {

        //使用类GirlFriend（模板）创建我心中的女朋友
        //类名 对象名 = new 类名();
        GirlFriend girlFriend1 = new GirlFriend();
        girlFriend1.name = "刘亦菲";
        girlFriend1.age = 80;
        girlFriend1.gender = '女';
        girlFriend1.height = 165;
        girlFriend1.weight= 43;

        //输出创建的对象信息
        girlFriend1.printGirlFriendInfo();

        System.out.println("---------");

        //创建第二个女朋友对象
        GirlFriend girlFriend2 = new GirlFriend();
        girlFriend2.name = "王祖贤";
        girlFriend2.age = 21;
        girlFriend2.gender = '女';
        girlFriend2.height = 168;
        girlFriend2.weight= 48;
        //输出对象信息
        girlFriend2.printGirlFriendInfo();
        //调用其它方法
        girlFriend2.eat();
        girlFriend2.sleep();


    }

}

package Learn3;

public class Dog {
    //定义属性
    public String name;
    public int health;
    public int love;

    //定义方法
    public void print(){
        System.out.println("狗的信息：");
        System.out.println("名称："+name+"，健康值："+health+"，亲密度："+love);
    }

}

package Learn3;

public class DogTest {

    public static void main(String[] args) {
        //创建Dog类对象
        //类名 对象名 = new 类名();
        Dog dog1 = new Dog();
        //给属性赋值
        dog1.name = "Happy";
        dog1.health = 100;
        dog1.love = 90;

        //调用方法输出dog1对象的信息
        dog1.print();
    }

}

package Learn4;

public class Teacher {

    //定义属性
    public String name;
    public String major;
    public String teachingCourses;
    public int lengthOfTeaching;

    //定义方法
    public void print() {
        System.out.println(name);
        System.out.println("专业方向：" + major);
        System.out.println("教授课程：" + teachingCourses);
        System.out.println("教龄：" + lengthOfTeaching);
    }
}

package Learn4;
public class TeacherTest {

    public static void main(String[] args) {
        //创建Teacher类对象
        Teacher teacher1 = new Teacher();
        //给属性赋值
        teacher1.name = "王老师";
        teacher1.major = "计算机";
        teacher1.teachingCourses = "使用Java理解程序逻辑";
        teacher1.lengthOfTeaching = 5;

        //通过teacher1对象调用方法输出对象信息
        teacher1.print();

        System.out.println("---------------------------");

        Teacher teacher2 = new Teacher();
        teacher2.name = "张老师";
        teacher2.major = "计算机";
        teacher2.teachingCourses = "Java从入门到精神病医康复指南";
        teacher2.lengthOfTeaching = 5;

        teacher2.print();


    }

}

package Learn5;

public class MethodDemo01 {
    /*
     * 方法的详细定义：
     *   1）根据方法是否有返回值，将方法分为无返回值的方法和有返回值的方法
     *       --》无返回值的方法，返回值类型写void
     *       --》有返回值的方法，返回值类型写返回数据的类型
     *           有返回值的方法，需要通过return关键字返回指定的数据类型
     *
     * */

    //定义一个无返回值的方法
    public void m1(){
        System.out.println("m1()是一个无返回值的方法");
    }

    //定义一个返回int类型数据的方法m2()
    public int m2(){
        int num = 300;
        return num;
    }

    //定义一个返回String类型数组的方法
    public String[] m3(){
        String[] strs = {"qwert","asdfg"};
        return strs;
    }

}

package Learn5;

import java.util.Arrays;

public class MethodDemo01Test {

    public static void main(String[] args) {

        //创建MethodDemo01对象
        MethodDemo01 methodDemo01 = new MethodDemo01();
        //调用无返回值的方法m1
        //调用没有返回值的方法时，直接调用方法，不需要再做其他任何操作
        methodDemo01.m1();

        //调用有返回值的方法m2
        //方法返回什么类型的结果，就使用什么类型的变量接收返回值
        int result1 =methodDemo01.m2();
        System.out.println("result1:"+result1);

        //不适用变量接收方法返回值，直接将返回值输出
        System.out.println(methodDemo01.m2());

        //调用有返回值的方法m3
        String[] strings =methodDemo01.m3();
        System.out.println(Arrays.toString(strings));


    }

}

package Learn5;

public class MethodDemo02 {

    /*
     * 方法的详细定义：
     *   根据方法是否有参数来分类：
     *       --》无参方法：没有参数的方法
     *       --》有参方法：有参数的方法，参数可以是一个或者多个，可以是相同类型的也可以是不同类型的
     *
     * 根据MethodDemo01类中的分类，方法最终的表现形式有四种：
     *      1）无返回值的无参方法
     *      2）无返回值的有参方法
     *      3）有返回值的无参方法
     *      4）有返回值的有参方法
     * 方法的调用原则：
     *   1）给什么接什么：方法返回什么类型的值，要么直接输出返回值，要么拿对应类型的变量接收返回值
     *   2）要什么给什么：方法需要什么样的参数，按照参数列表的要求传递参数
     * */

    //定义一个无参方法
    public void m1(){
        System.out.println("没有参数的方法m1()");
    }

    //定义一个需要传递一个int类型数据的方法
    public void m2(int num){//num是一个形式参数，简称形参
        System.out.println("你传递过来的值："+num);
    }

    //定义一个需要传递两个int类型数据的方法
    public void m3(int num1,int num2){
        System.out.println("你传递过来的两个数据之和："+(num1+num2));
    }

    //定义一个需要传递一个int类型数据和一个double类型数据的方法
    public void m4(int num1,double num2){
        System.out.println("你传递过来的两个数据是："+num1+"，"+num2);
    }

    //定义一个方法，需要传递一个int类型的数组，然后将传递过来的数组元素进行求和，将结果和返回
    public int arraySum(int[] nums){
        //声明一个变量sum用来累加数组之和
        int sum = 0;
        //通过循环进行累加
        for(int i =0;i<nums.length;i++){
            sum+=nums[i];
        }
        return sum;
    }

}

package Learn5;

public class MethodDemo02Test {

    public static void main(String[] args) {

        //创建MethodDemo02类对象
        MethodDemo02 methodDemo02 = new MethodDemo02();

        //调用无参方法：不需要传递参数
        methodDemo02.m1();

        //调用有参方法，传递一个int类型数据
        methodDemo02.m2(200);//调用方法时传递的实际参数是200，简称实参
        int a =300;
        methodDemo02.m2(a);//调用方法时传递的实际参数是a，简称实参
        //methodDemo02.m2(199.99); m2方法需要的是int类型的，你传递的是double类型的数据，不负好参数列表要求

        //调用有参方法，传递两个int类型数据
        methodDemo02.m3(100,200);

        //调用有参方法，传递一个int类型数据和一个double类型数据
        methodDemo02.m4(100,99.99);
        //methodDemo02.m4(99.99,100); //调用有参方法时需要根据参数的类型、个数、顺序传递参数

        //总结：调用有参方法时，必须按照方法参数列表的数据类型、个数、顺序要求传递参数

        //定义一个int类型数组
        int[] array1 = {11,22,33};
        int result1 = methodDemo02.arraySum(array1);
        System.out.println("array1数组元素之和："+result1);

        int[] array2 = {11,33,44,55,66};
        System.out.println(methodDemo02.arraySum(array2));



    }

}

package Learn5;

public class MethodDemo03 {

    /*
     * 方法的三种调用方式：
     *   1）通过对象调用方法：在其他类中调用非静态方法
     *   2）通过类名直接调用方法：要求方法使用static修饰，直接通过类名.方法名()
     *   3）在同一个类中，方法之间可以直接调用，无需创建对象或者通过类名调用
     *       非静态方法（没有使用static修饰的方法）既可以调用非静态方法，也可以调用静态方法
     *       静态方法只能调用静态方法
     *
     * */

    public void m1(){
        System.out.println("无返回值的无参方法m1()");
    }

    public void m2(){
        System.out.println("无返回值的无参方法m2()");
        m1();
        m3();//非静态方法中既可以调用非静态方法，也可以调用静态方法
    }

    public static void m3(){
        System.out.println("使用static修饰的无参回值的无参方法m3()");
    }

    public static void m4(){
        System.out.println("使用static修饰的无参回值的无参方法m4()");
        m3();
        //m1(); 静态方法中只能调用同一个类的静态方法，不能调用非静态方法
    }

}

package Learn5;

public class MethodDemo03Test {

    public static void main(String[] args) {

        //调用方法的方式一：通过对象调用方法
        MethodDemo03 methodDemo03 = new MethodDemo03();
        methodDemo03.m1();

        //调用方法的方式而：通过类名调用方法
        methodDemo03.m3();//使用static修饰的方法也可以通过对象名调用
        //类名调用方法
        MethodDemo03.m3();

        System.out.println("--------------------");

        methodDemo03.m2();

        System.out.println("--------------------");

        MethodDemo03.m4();






    }

}