javaoop-day01

luoyiang

已于 2024-07-26 19:19:30 修改

阅读量261

点赞数 6

文章标签： java 开发语言

于 2024-07-26 19:19:13 首次发布

本文链接：https://blog.csdn.net/m0_64370841/article/details/140722782

版权

pojo_Person

package com.oop.pojo;

/**
 * 包的概念
 *   1. 关键词: package
 *   2. 用来管理各种源文件，即.java文件
 *          如： 所有的实体类，一般都放在com.公司名.项目名.模块名.实体
 *                    reg: com.yc.oop.mgr.pojo(vo ,entity)
 *               所有的工具类，一般都放在com.公司名.项目名.模块名.工具
 *                    reg: com.yc.oop.mgr.utils
 *               所有的控制类:
 *                    reg: com.yc.oop.mgr.controller
 *                所有的服务类:
 *                    reg: com.yc.oop.mgr.service
 *
 */

public class Person {
    // 成员变量： 这类事物的共同特征，即状态数据，一堆不同类型的变量。 也可以属性/全局变量
    String name;
    int age;
    char gender;

    //成员方法： 这类事物的共同行为，可以在这里直接操作成员变量
    public void eat(String food){
        System.out.println("吃的食物是"+food);
    }

    public void play(String game){
        System.out.println(name+"玩的游戏是"+game);
    }

    public void work(){
        System.out.println(name+"正在工作");
    }

    //可变长参数:  数据类型...变量名，  注意:该变量是数组。  可变长参数只能放在最后面
    public long calculate(int ... a ){
        long sum = 0;
//        for (int i = 0; i < a.length; i++){
//            sum += a[i];
//        }
        for (int i : a) {
            sum += i;
        }
        return sum;
    }
}

pojo_PersonTest

package com.oop.pojo;

import com.oop.pojo.Person;

/**
 * 成员的访问：
 *  通过引用变量和点来访问
 */

public class PersonTest {
    public static void main(String[] args) {
        //创建Person类型的一个对象
        Person p1 = new Person();
        //注意:在没赋值之前，成员变量都是有默认值的。
        System.out.println(p1.name); //引用类型的默认值null
        System.out.println(p1.age); //byte,short,int,long的默认值是0
        System.out.println(p1.gender); //char的默认值lu0000

        // 给对象的成员变量赋值
        p1.name = "micheal";
        p1.age = 18;
        p1.gender = '男';
        System.out.println(p1.name);
        System.out.println(p1.age);
        System.out.println(p1.gender);

        //上述是成员变量的访问，也可以使用该方法访问成员方法
        p1.eat("苹果");
        p1.play( "王者荣耀");
        p1.work();
        long sum = p1.calculate( 3,4,5,6,7);
        System.out.println(sum);
    }
}

pojo_PersonTest2

package com.oop.pojo;

/**
 * null和nullPointerException
 *   null:
 *       1. 引用类型的默认值。 表示引用变量里的地址被清空，即无对象的地址信息
 *           String str = null;
 *           Person p = null;
 *   nullPointerException:
 *       1. 空指针异常: 运行时发生的
 *       2. 变量里面没有地址信息，却使用变量来访问对象的成员。就会发生该异常
 */

public class PersonTest2 {
    public static void main(String[] args) {
        String str = "Hello World";
        System.out.println(str.length());
        str = null; //清空地址信息
        System.out.println(str.length()); //空指针异常，没有地址指向对象，确访问了对象的成员

        Person person = new Person();
        System.out.println(person.name);//null
        person.name = null;
        System.out.println(person.name.length()); //空指针异常
    }
}

pojo_Computer

package com.oop.pojo;

/**
 * 共同特征：
 *     品牌：String
 *     型号：String
 *     颜色：String
 *     显示器尺寸：String
 *
 *  共同行为：
 *     open()
 *     close()
 *     inserusb(String usb)
 *
 */

public class Computer {
    String brand;
    String model;
    String color;
    String size;

    public void open( ){
        System.out.println("打开电脑");
    }

    public void close( ){
        System.out.println("关闭电脑");
    }

    public void insertUsb(String usb){
        System.out.println("插入"+usb);
    }
}

pojo_ComputerTest

package com.oop.pojo;

/**
 * 包的概念(续)
 *   1. 在一个类A中，如果想要使用别的类B，并且类B不和类A同包，那么就需要
 *       import，导入操作; 将其引入到该类中，才能使用类B中的方法
 *   2. 类的名字
 *       类名： 类的短名
 *       类全名： 从最外层的包开始写的名字，比如Computer这个类
 *         Computer就是短名，简称类名
 *         全名： com.oop.pojo.Computer
 */

public class ComputerTest {
    public static void main(String[] args) {
        /*
             创建Computer对象 语法：new 类名(); 该过程称为实例化

             引用变量：
                引用类型声明的变量，称为引用变量，简称引用。 因为里面存储不是对象，储存的是对象的内存地址

                引用变量，说的是可以通过自己存存的地址找到那个对象，替代了c语言里面的指针


         */
        Computer c1 = new Computer();
        Person p1 = new Person();

        Computer c2 = new Computer();
        Person p2 = new Person();


    }
}

pojo_Person2

package com.oop.pojo;

/**
 * 定义一个Person2类型
 * 构造器的相关知识点：
 *   1. 类体中，程序员没有提供任何构造器时候，系统已经提供了无参数的构造器
 *       public 类名(){}
 *   2. 程序员一旦提供构造器，系统就不再提供那个无参构造器
 *   3. 构造器也是一个方法，但是没有返回值类型这个位置，名字与类名一致
 *   4. 构造器不能使用static修饰
 *   5. 构造器可以重载，只需要形参列表不一样就可以、
 *   6. 构造器的作用就是给成员变量初始化
 */

public class Person2 {
    String name;
    int age;
    char gender;

    //无参构造器
    public Person2() {
        System.out.println("无参数的构造器");
    }

    //全参构造器
    public Person2(String name, int age, char gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
        System.out.println("全参数的构造器");
    }

    public Person2(String name, char gender){
        this.name = name;
        this.gender = gender;
        this.age = 18; //明确赋值
        System.out.println("两参数的构造器");
    }
    
    public void showInfo() {
        System.out.println("name"+name);
        System.out.println("age"+age);
        System.out.println("gender"+gender);
    }
}

pojo_PersonTest2

package com.oop.pojo;

/**
 * 构造器的调用：
 *   1. 使用new关键字
 *       new 构造方法(有参传参)
 */
public class Person2Test {
    public static void main(String[] args) {
        //调用Person2的无参构造器实例化和初始化一个对象
        Person2 p1 = new Person2();
        p1.showInfo(); //因为无参构造器中没有初始化操作，因此都是默认值

        //调用全参构造器实例化和初始化一个对象    ctrl+p： 用于查看重载的方法参数
        Person2 p2 = new Person2("小明",20,'男');
        p2.showInfo();

        //调用两个参数的构造器，实例化和初始化一个对象
        Person2 p3 = new Person2("小红",'女');
        p3.showInfo();
    }
}

pojo_Cat

package com.oop.pojo;

/**
 *  this.关键字
 *     this. 是隐藏在成员方法里的成员变量前面的关键字
 */

public class Cat {
    String name;
    String brand;
    String color;

    public void setInfo( String a, String b, String c){
        //成员变量前，隐藏了this. 可以写也可以省略
        name = a;
        this.brand = b;
        color = c;
    }
    public void setInformastion(String name, String brand, String color){
        //当形式参数的名字和成员变量的名字相同时，如果想要在这个作用域内
        //表示成员变量，需要使用this.不能省略
        this.name = name;
        this.brand = brand;
        this.color = color;
    }

    public void showInfo(){
        System.out.println("name" + name + "brand" + brand +"color"+color);
    }

    public static void main(String[] args) {
        //创建Cat对象
        Cat c1 = new Cat();
        //调用setInfo给c1对象赋值
        c1.setInfo("coke","英短","白色");
        //调用showInfo方法 27行
        c1.showInfo();

         //调用setInformastion修改对c1对象赋值
        c1.setInformastion( "code","逻辑","黑色");
        c1.showInfo();
    }
}

pojo_Person3

package com.oop.pojo;

/**
 *  构造器的调用(续)：
 *    1. 在构造器可以使用this(有参传参)的方式调用本类中的其他构造器
 *    2. this()只能写在构造器的第一行
 */
public class Person3 {
    String name;
    int age;
    char gender;

    public  Person3(){
        this.name = "";
        this.age = -1;
        this.gender = 'f';
    }
    public Person3(String name){
        this.name = name;
    }
    public Person3(String name, int age){
        //调用了本类中的一个参数构造器
        this(name);
        this.age = age;
    }
    public Person3( String name, int age, char gender) {
        //调用了本类中的两个参数构造器
        this(name, age);
        this.gender = gender;
    }
        public void showInfo(){
            System.out.println("name"+name);
            System.out.println("age"+age);
            System.out.println("gender"+gender);
        }
        public static void main(String[] args) {
            Person3 p1 = new Person3("小黑", 18);
            p1.showInfo();

            //调用全参构造器
            Person3 p2 = new Person3( "小明", 18, '男');
            p2.showInfo();
    }
}

exercise_Exercise

package com.oop.exercise;

/*
  要求:
1.提供一个全参数的构造器
2.提供一个用户名和密码的构造器。默认的邮箱地址是:用户名@yc.com
3.提供一个showInfo方法
3.测试1:调用全参构造器，显示信息
  测试2:调用两个参数构造器，显示信息
 */

public class Exercise {
    String name;
    String password;
    String email;

    public Exercise(String name, String password, String email) {
        this.name = name;
        this.password = password;
        this.email = email;
    }

    public Exercise(String name, String password) {
        this.name =name;
        this.password = password;
        this.email = name+ "@yc.com" ;
    }

    public void showInfo() {
        System.out.println("name" + name);
        System.out.println("password" + password);
        System.out.println("email" + email);
    }

    public static void main(String[] args) {
        // 测试1: 调用全参构造器
        Exercise user1 = new Exercise("A", "123", "alice@example.com");
        user1.showInfo();

        // 测试2: 调用两个参数构造器
        Exercise user2 = new Exercise("B", "456");
        user2.showInfo();

    }
}

exercise_Interview

package com.oop.exercise;

import java.util.Arrays;

public class Interview {
    public static void main(String[] args) {
        int a = 5;
        char[] chs = {'m','n','p'};
        char[] rs = m(a,chs);
        System.out.println(a); //5
        System.out.println(Arrays.toString(rs)); //[m, x, p]
        System.out.println(Arrays.toString(chs)); //[m, x, p]
    }
    public static char[] m(int a, char[] chs) {
        a = 10;
        chs[1] = 'x';
        return chs;
    }
}

contain_PersonTest

package com.oop.contain;

import com.oop.pojo.Person2;

/**
 * JVM内存管理机制：
 *
 */

public class PersonTest {
    public static void main(String[] args) {
        int a = 18;
        char b = 'a';
        long c = add(a,b);
        System.out.println("c="+c);

        Person2 p = new Person2( "小明", 18, '女');
        p.showInfo();
    }
    public static long add(int a, int b) {
        int x = a ;
        int y = b ;
        int z = x + y ;
        return z ;

    }
}

codeblock_blockDemo

package com.oop.codeblock;

/**
 *  代码块的学习：
 *    1. 动态代码块(构造代码块)
 *    语法：
 *    {
 *        代码片段
 *    }
 *     位置：与构造器并列，都是在类体中
 *     特点: 构造器执行一次，动态代码块就执行一次，并先于构造器执行。
 *     作用：一般用于统计一个类型创建了多少个对象，或者提前给成员变量赋值
 *
 *    2.静态代码块(静态块)
 *    语法：
 *     static{
 *         代码片段
 *     }
 *     位置: 与构造器并列，都是在类体中
 *     特点: 只执行一次，在类加载器将该类的信息家在到内存时，执行的
 *     作用: 一般用于加载静态资源到内存中，比如图片，音乐，视频等
 *
 */

public class BlockDemo {
    public static void main(String[] args) {
        //调用无参构造器实例化对象
        BlockDemo bd = new BlockDemo();
        System.out.println(bd);
        // 调用有参构造器实例化对象
        BlockDemo bd2 = new BlockDemo(10,20);
        System.out.println(bd2); //默认调用toString()方法
    }

    int a;
    int b;
    static{
        System.out.println("静态代码块执行了");
    }

    {
        System.out.println("动态代码块执行了");
    }

    public BlockDemo() {
        System.out.println("无参构造器执行了");
    }

    public BlockDemo(int a, int b) {
        System.out.println("有参构造器执行了");
        this.a = a;
        this.b = b;
    }
    /*
      String toString(): 将对象的成员信息便于一串字符串，并返回
       该方法，在将引用变量放在输出语句中时，会默认调用
     */
    public String toString(){
        return "a = "+a+", b = "+b;
    }
}