有效沟通问答-【官方】百战程序员_IT在线教育培训机构

会员可以在此提问，百战程序员老师有问必答

对大家有帮助的问答会被标记为“推荐”
看完课程过来浏览一下别人提的问题，会帮你学得更全面

截止目前，同学们一共提了 132450个问题

时间排序推荐排序

老师我想问一下，为什么我的这次练习找不到i呢？在打代码的时候报了一遍错。之后我就蒙了

JAVA 全系列/第二阶段：JAVA 基础深化和提高/Lambda表达式（旧） 1381楼

老师，如果对方使用了Apache IO包，而我没有下载包，程序能在我的电脑上运行吗

JAVA 全系列/第二阶段：JAVA 基础深化和提高/IO 流技术（旧） 1382楼

为什么要写if（fr != null）判断后再执行fr.close，不写的话，也是会执行关闭，是会容易出现错误吗

JAVA 全系列/第二阶段：JAVA 基础深化和提高/IO 流技术（旧） 1383楼

有两个问题

1）

关于获取成员变量的值：

Object o = field.get(obj);

这里的成员变量userage是int类型的，这里是因为向上转型，所以可以使用Oject o来存储18这个int类型变量吗？

如果直接使用int类型变量来获取是否可以呢？即：

int t = field.get(obj);

2关于最后一行打印o，

因为o实际是int类型数据向上转型，我不懂这里如果要打印它，为什么不需要强制转型为int，才打印？

我理解的是，因为toString方法是Object类下的，所以可以直接打印出来，对于Object类型下的方法调用，不需要强制向下转型，也可以调用。

如果是int独有的方法，比如加减乘除，就必须强制转型成int。

不知道我理解的是否对？

JAVA 全系列/第二阶段：JAVA 基础深化和提高/反射技术（旧） 1384楼

看着看着，有点乱，不知道这两个方法有什么作用？请老师解答

JAVA 全系列/第二阶段：JAVA 基础深化和提高/容器（旧） 1385楼

老师，同步代码块中 wait(）方法及 notify() 方法是用 this 对象调用的，那这个对象到底是哪个类下的对象？是缓冲区 BufferZone 类下实例化的对象嘛？

// 馒头类
class SteamBread {
    private int id;

    public SteamBread(int id) {
        this.id = id;
    }

    public int getId() {
        return this.id;
    }
}

// 缓冲区类
class BufferZone {
    // 存放馒头的盒子
    private SteamBread[] sb = new SteamBread[10];
    // 定义操作盒子的索引
    private int index;

    // 生产者方法馒头
    public synchronized void put(SteamBread steamBread) {
        while (this.index >= this.sb.length) {
            try {
                this.wait();   // this 引用当前类的实例，所以对应的对象为 BufferZone 类下实例化的对象 bz
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.notify();
        this.sb[this.index] = steamBread;
        this.index++;
    }

    // 取馒头
    public synchronized SteamBread take() {
        while (this.index == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.notify();
        this.index--;
        return this.sb[this.index];
    }
}

// 生产者线程类
class ProducerThread extends Thread {
    private BufferZone bz;

    public ProducerThread(BufferZone bz) {
        this.bz = bz;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; ++i) {
            System.out.println("生产馒头:" + i);
            SteamBread sb = new SteamBread(i);
            this.bz.put(sb);
        }
    }
}

// 消费者线程类
class ConsumerThread extends Thread {
    private BufferZone bz;

    public ConsumerThread(BufferZone bz) {
        this.bz = bz;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; ++i) {
            SteamBread sb = this.bz.take();
            System.out.println("消费馒头:" + i);
        }
    }
}


// 测试生产者消费者模式
public class ProducerConsumerModel {
    public static void main(String[] args) {
        BufferZone bz = new BufferZone();
        new ProducerThread(bz).start();
        new ConsumerThread(bz).start();
    }

}

JAVA 全系列/第二阶段：JAVA 基础深化和提高/多线程技术（旧） 1386楼

老师，同步代码块中 wait(）方法及 notify() 方法是用 this 对象调用的，那这个对象到底是哪个类下的对象？是缓冲区 BufferZone 类下实例化的对象嘛？

// 馒头类
class SteamBread {
    private int id;

    public SteamBread(int id) {
        this.id = id;
    }

    public int getId() {
        return this.id;
    }
}

// 缓冲区类
class BufferZone {
    // 存放馒头的盒子
    private SteamBread[] sb = new SteamBread[10];
    // 定义操作盒子的索引
    private int index;

    // 生产者方法馒头
    public synchronized void put(SteamBread steamBread) {
        while (this.index >= this.sb.length) {
            try {
                this.wait();   // this 引用当前类的实例，所以对应的对象为 BufferZone 类下实例化的对象 bz
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.notify();
        this.sb[this.index] = steamBread;
        this.index++;
    }

    // 取馒头
    public synchronized SteamBread take() {
        while (this.index == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.notify();
        this.index--;
        return this.sb[this.index];
    }
}

// 生产者线程类
class ProducerThread extends Thread {
    private BufferZone bz;

    public ProducerThread(BufferZone bz) {
        this.bz = bz;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; ++i) {
            System.out.println("生产馒头:" + i);
            SteamBread sb = new SteamBread(i);
            this.bz.put(sb);
        }
    }
}

// 消费者线程类
class ConsumerThread extends Thread {
    private BufferZone bz;

    public ConsumerThread(BufferZone bz) {
        this.bz = bz;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; ++i) {
            SteamBread sb = this.bz.take();
            System.out.println("消费馒头:" + i);
        }
    }
}


// 测试生产者消费者模式
public class ProducerConsumerModel {
    public static void main(String[] args) {
        BufferZone bz = new BufferZone();
        new ProducerThread(bz).start();
        new ConsumerThread(bz).start();
    }

}

JAVA 全系列/第二阶段：JAVA 基础深化和提高/多线程技术（旧） 1387楼

// 程序员奖金类
class ProgrammerBonus {
    private String name;

    public ProgrammerBonus(String name) {
        this.name = name;
    }
    // 领取奖金
    public void TakeBonus () {
        // 不仅可以用 ProgrammerBonus.class，用 Bonus.class 也行
        synchronized (Bonus.class) {
            try {
                System.out.println(this.name + "被领导表扬");
                Thread.sleep(3000);
                System.out.println(this.name + "拿到奖金");
                Thread.sleep(2000);
                System.out.println(this.name + "话不多说，一切尽在行动中");
                Thread.sleep(3000);
                System.out.println(this.name + "离开办公室");
                Thread.sleep(4000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

// 领取奖金线程
class Bonus extends Thread {
    private ProgrammerBonus pb;

    public Bonus(ProgrammerBonus pb) {
        this.pb = pb;
    }

    @Override
    public void run() {
       this.pb.TakeBonus();
    }
}

public class ThreadConflictTest03 {

    public static void main(String[] args) {
        ProgrammerBonus pb1 = new ProgrammerBonus("张三");
        Bonus b1 =new Bonus(pb1);
        ProgrammerBonus pb2 = new ProgrammerBonus("李四");
        Bonus b2 = new Bonus(pb2);
        ProgrammerBonus pb3 = new ProgrammerBonus("王五");
        Bonus b3 = new Bonus(pb3);

        b1.start();
        b2.start();
        b3.start();
    }
}

老师，在上面代码中，用类对象作为锁对象，我试了下发现用 ProgrammerBouns.class 或 Bouns.class 都可以，这两个类对象用起来有啥区别嘛？

JAVA 全系列/第二阶段：JAVA 基础深化和提高/多线程技术（旧） 1388楼

public class Generic <T>{
    T name;
    T age;

    public Generic() {
    }

    public T getName() {
        return name;
    }

    public void setName(T name) {
        this.name = name;
    }

    public T getAge() {
        return age;
    }

    public void setAge(T age) {
        this.age = age;
    }

    public static void main(String[] args) {
        Generic<String> g1 = new Generic<>();
        g1.setName("胖鱼");
        g1.setAge("20");
        System.out.println(g1.getName() + "..." + g1.getAge());

    }
}

老师你看我这么理解对吗

泛型类，其实是规定了这个类的对象的成员的数据类型，创建对象时加入泛型<String>，这个对象的类型依然是Generic类型，这个对象的属性的数据类型都变成了String类型

JAVA 全系列/第二阶段：JAVA 基础深化和提高/容器（旧） 1389楼

老师，线程同步中，使用字符串作为锁对象为何就可以实现不同对象调用同一线程的同步？这种方式锁定的到底是什么？锁定的肯定不是创建的实例化对象吧，因为使用了不同的实例化对象去调用同一线程。

// 程序员类
class Programmers{
    private String name;

    public Programmers(String name) {
        this.name = name;
    }

    // 上洗手间
    public void wc () {
        // 以空字符串为锁对象
        synchronized ("　") {
            try {
                System.out.println(this.name + "打开卫生间门");
                Thread.sleep(3000);
                System.out.println(this.name + "上厕所");
                Thread.sleep(3000);
                System.out.println(this.name + "来也匆匆，去也冲冲");
                Thread.sleep(4000);
                System.out.println(this.name + "打开卫生间门");
                Thread.sleep(4000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

// 上洗手间线程
class WC extends Thread {
    private Programmers pn;

    public WC(Programmers pn) {
        this.pn = pn;
    }

    @Override
    public void run() {
        this.pn.wc();
    }
}

public class ThreadConflictTest02 {

    public static void main(String[] args) {
        Programmers ps1 = new Programmers("张三");
        Programmers ps2 = new Programmers("李四");
        Programmers ps3 = new Programmers("王五");
        new WC(ps1).start();
        new WC(ps2).start();
        new WC(ps3).start();

    }
}

JAVA 全系列/第二阶段：JAVA 基础深化和提高/多线程技术（旧） 1390楼

老师好，有三个问题：

1）对于对象在网络传输，要用serializable接口，这里说的是对UDP，那么对于TCP，是否也是一样的？

2）对于非基本数据类型，是否都是可以通过ObjectInputStream方法进行数据的接受和读取？比如之前对String类型，是用的new String（）

那么是否对于String类型这种非基本数据类型的对象，也可以用本节所讲的方法进行操作？

3）我记得之前讲Object向下，必须进行强制转型操作，这里没有对Object强制转型为Person类，为什么还可以对这个对象进行操作? 是否只有调用toString方法，才不需要强制转型，如果调用该类的普通方法或者属性，则必须强制转型为Person才可以？

JAVA 全系列/第二阶段：JAVA 基础深化和提高/网络编程（旧） 1391楼

有3个问题：

想问下，这个8888端口，是客户端发送数据的端口？服务端接收数据的端口是9999，被封装在dp中。

数据通过客户端的8888端口把数据发出去，根据dp中ip和端口，找到服务器，才被接收？

看之前别的回答，写到如果用一个端口会有端口冲突问题，因为现在的服务端和客户端都在一个ip地址内，如果是不同的ip地址，是不是端口冲突也无所谓了？

为什么在TCP中，没有发送数据并且定义端口这个过程，而是可以直接通过socket，给定服务器的ip地址和端口，就可以发送数据，这里是没有发送数据的过程，还是说这个过程和定义服务端发送端口的操作，被自动实现了？

JAVA 全系列/第二阶段：JAVA 基础深化和提高/网络编程（旧） 1392楼

这个是错误的提示，所以说老师我想问一下错在了哪里？

JAVA 全系列/第二阶段：JAVA 基础深化和提高/反射技术（旧） 1393楼

这个是个什么情况？一直让我加try/catch，错在哪里了呢？

JAVA 全系列/第二阶段：JAVA 基础深化和提高/反射技术（旧） 1394楼

field.get(obj),获取对象,打印结果为什么是18,而不是一个obj包含18,谢谢

JAVA 全系列/第二阶段：JAVA 基础深化和提高/反射技术（旧） 1395楼

同学您好