一道笔试题，引发我的基础问题的反思

最新推荐文章于 2021-12-22 16:17:10 发布
最新推荐文章于 2021-12-22 16:17:10 发布
阅读量398 收藏
点赞数 1
分类专栏： Java基础误区
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32519097/article/details/52938700
版权

我是这样做这道题的：

package 农金圈;



//两个线程一个打印a-z，一个线程打印A-Z

public class ThreadPrint {

    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        Object obj=new Object();

        //新建实例，并启动线程
        Thread1 t1=new Thread1(obj);
        Thread2 t2=new Thread2(obj);
        t1.start();
        t2.start();
    }


    //线程第一步
 class Thread1 extends Thread
    {
        //新建一个代码块进行同步
    private Object obj;
    public Thread1(Object obj)
    {
        this.obj=obj;
    }
        //线程第二步
        //重写run（）方法
        public void run()
        {
            //要进行同步代码块

            synchronized(obj)
            {

                for(int i=0;i<26;i++)
                {
                    System.out.println((char)('a'+i)+" ");
                    obj.notifyAll();
                      try
                        {
                            if(i!=25)
                            {
                                //当线程在活动之前或活动期间处于正在等待、休眠或占用状态且该线程被中断时，抛出该异常
                            obj.wait();
                            }
                        }
                        catch(InterruptedException e)
                        {
                            e.printStackTrace();
                        }
                    }
                }
            }
      } 




    //创立第二个线程
    class Thread2 extends Thread
    {
        private Object obj;
        public Thread2(Object obj) 
        {
            this.obj=obj;
        }
        public void run()
        {
            synchronized(obj)
            {
            for(int i=0;i<26;i++)
            {
                System.out.println((char)('A'+i)+" ");
                obj.notifyAll();    
                    try
                    {
                        if(i!=25)
                        {
                        obj.wait();
                        }
                    }
                    catch(InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                }

            }
        }
     }

}

这里告诉我一个错误，一个有关内部类基础的错误。
首先我们要明白一个道理就是有关权限修饰符：public（公开访问权限）、protected（子类访问权限）、default（默认访问权限）、private（当前类访问权限）。

首先我们来明确一下类的基本概念，类分为外部类还有内部类，外部类你既然写在外面那么对应的访问权限，应该就是包还有public，也就是常说到的public和default（默认），在外部类里面加一个内部类，你想想呀，内部类对应的权限是不是private（当前类）还有（子类访问权限），子类访问权限对应的是当前包以及其他包下的子类，public ，default。如果这个时候你用到的是static，那就是静态内部类了。
而我上面的代码很明显，有问题：什么问题呢？
1内部类如果需要加载的话，必须先实例化外部类，然后在用内部类来实现。
2直接用static方法，直接实例化。
3将这个内部类放在与原外部类的外面，相当于没有单独的类的属性。

附上解决2 和解决3的代码，一的还没想出来

package 农金圈;

//两个线程一个打印a-z，一个线程打印A-Z

public class ThreadPrint {

    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        Object obj=new Object();

        //新建实例，并启动线程
        Thread1 t1=new Thread1(obj);
        Thread2 t2=new Thread2(obj);
        t1.start();
        t2.start();
    }


    //线程第一步
static class Thread1 extends Thread
    {
        //新建一个代码块进行同步
    private Object obj;
    public Thread1(Object obj)
    {
        this.obj=obj;
    }
        //线程第二步
        //重写run（）方法
        public void run()
        {
            //要进行同步代码块

            synchronized(obj)
            {

                for(int i=0;i<26;i++)
                {
                    System.out.println((char)('a'+i)+" ");
                    obj.notifyAll();
                      try
                        {
                            if(i!=25)
                            {
                                //当线程在活动之前或活动期间处于正在等待、休眠或占用状态且该线程被中断时，抛出该异常
                            obj.wait();
                            }
                        }
                        catch(InterruptedException e)
                        {
                            e.printStackTrace();
                        }
                    }
                }
            }
      } 




    //创立第二个线程
static  class Thread2 extends Thread
    {
        private Object obj;
        public Thread2(Object obj) 
        {
            this.obj=obj;
        }
        public void run()
        {
            synchronized(obj)
            {
            for(int i=0;i<26;i++)
            {
                System.out.println((char)('A'+i)+" ");
                obj.notifyAll();    
                    try
                    {
                        if(i!=25)
                        {
                        obj.wait();
                        }
                    }
                    catch(InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                }

            }
        }
     }

}



package Test;

 class Thread1 extends Thread
{
    //新建一个代码块进行同步
private Object obj;
public Thread1(Object obj)
{
    this.obj=obj;
}
    //线程第二步
    //重写run（）方法
    public void run()
    {
        //要进行同步代码块

        synchronized(obj)
        {

            for(int i=0;i<26;i++)
            {
                System.out.println((char)('a'+i)+" ");
                obj.notifyAll();
                  try
                    {
                        if(i!=25)
                        {
                            //当线程在活动之前或活动期间处于正在等待、休眠或占用状态且该线程被中断时，抛出该异常
                        obj.wait();
                        }
                    }
                    catch(InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                }
            }
        }
  } 

 class Thread2 extends Thread
 {
    //新建一个代码块进行同步
 private Object obj;
 public Thread2(Object obj)
 {
    this.obj=obj;
 }
    //线程第二步
    //重写run（）方法
    public void run()
    {
        //要进行同步代码块

        synchronized(obj)
        {

            for(int i=0;i<26;i++)
            {
                System.out.println((char)('a'+i)+" ");
                obj.notifyAll();
                  try
                    {
                        if(i!=25)
                        {
                            //当线程在活动之前或活动期间处于正在等待、休眠或占用状态且该线程被中断时，抛出该异常
                        obj.wait();
                        }
                    }
                    catch(InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                }
            }
        }
   }    


public class ThreadPrint {

    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        Object obj=new Object();

        //新建实例，并启动线程
        Thread1 t1=new Thread1(obj);
        Thread2 t2=new Thread2(obj);
        t1.start();
        t2.start();
    }
}

插入一个外文找到答案的图片：这里写图片描述

FashionCodeBoy
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
15、线程（基础）
yys0628的博客
04-08 383
一、线程 1、概念介绍 2、单线程和多线程 3、并发和并行 二、线程基本使用 1、创建线程的两种方式 （1）案例1：继承 Thread 类 注：在多线程编程里面，不是main方法结束了，就意味着进程就结束了 //演示通过继承 Thread 类创建线程 public class Thread01 { public static void main(String[] args) throws InterruptedException {
Java的异常处理机制
quiet_1的博客
05-01 3688
一、什么是java异常？ java中所有错误的超类为：Throwable。其下有两个子类：Error 和 Exception。 Error的子类描述的都是系统错误，比如虚拟机内存溢出。 Exception的子类描述的都是程序，比如空指针，下标越界等。 通常我们程序中处理的异常都是Exception。 Java异常类的层次结构图： Java所有异常类都是Throwable的子类，它包括Java异常处理的两个重要子类：Error和Exception。 Error：Error及其子类用来描述Ja.
异常(一)
qq_43551976的博客
05-18 316
异常 public static void main(String[] args) { int a = 1/0; System.out.println(a); } 抛出异常 程序执行某个方法的时候，出现异常， 就会使用这个方法生成一个代表该异常的一个对象， 停止程序的运行，并且交给JRE，来进行处理 捕获异常 JRE得到这个异常的时候，就会寻找相应的代码来处理该异常， JR...
两道多线程打印题目
玩家六的专栏
05-27 419
1.每个线程打印不同的字符public class ThreadPrint { public static void main(String[] args) throws InterruptedException { String str = "ABCD"; int index = 4; Character c;
import java.io.*; public class FirstPart{ public static void main(String[] args) throws Exception{ System.out.print("The input Fahrenheit is "); BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); int f = Integer.parseInt(br.re
04-11
import java.io.*; public class FirstPart{ public static void main(String[] args) throws Exception{ System.out.print("The input Fahrenheit is "); BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); int f = Integer.parseInt(br.readLine()); double c=5*(f-32); c=c/9; System.out.println("Changing it to Celsius is "+c); } }
网络工程师招聘基础笔试题
04-01
网络工程招聘笔试题；题目是基础级别，但容易做错；参加笔试之前可以下载来看看；有几道题目答案错误，已在一篇博客中重新写出；
Java基础知识笔试题及答案
最新发布
11-23
Java 基础知识笔试题及答案 Java 是一种广泛使用的编程语言，它具有强大的功能和灵活性。本资源汇总了 Java 基础知识笔试题及答案，涵盖了 Java 的基本概念、数据类型、运算符、控制结构、函数、数组、集合框架、...
计算机文化基础(笔试题含答案).doc
04-14
计算机文化基础(笔试题含答案).doc
模拟IC实习秋招找工作笔试题
03-04
本文将针对“模拟IC实习秋招找工作笔试题”这一主题，详细介绍可能遇到的知识点，并提供一些备考策略。 首先，我们需要了解模拟IC的基本概念。模拟IC是集成电路的一种，其内部包含运算放大器、比较器、电源管理单元...
天地伟业 2011校招 计算机 笔试题
02-05
天地伟业，作为一家在信息技术领域有着显著影响力的公司，其2011年的校园招聘笔试题，旨在考察应聘者的计算机基础知识、编程能力以及问题解决技巧。 笔试试题通常涵盖以下几个方面： 1. **基础理论**：这部分可能...
JAVA笔记 ----- 线程操作的常用方法
qq_43514659的博客
02-09 123
线程操作的常用方法 线程可以进行命名，在Thread类里面，构造方法有两个参数的构造函数，可以直接命名名称。 public Thread(Runnable target, String name); 当然，也有设置名字和获取名称的方法，都是set和get方法。 然后我们看看，线程的命名规则 class MyThread implements Runnable{ // 线程的主体类 @Override public void run(){ System.out.pri
剑指Offer题4 —— public static void main (String[] args) throws java.lang.Exception { int[不修改数组找出重复数字
kanglupeng的专栏
02-07 1691
在一个长度为n+1的数组中，所有数组中的数字都在1～n的范围内，所以数组中至少有一个数字是重复的。请找出数组中任意一个重复的数字，但是不能修改输入的数组。例如输入长度为8的数组{2, 3, 5, 4, 3, 2, 6, 7}，应该输出2或3。 方案一：暴力解法 将数组中的元素两两相比，最差情况时间复杂度是O(n²). 方案二：使用Set 创建一个大小为n的Set，每次向Set中插入一个数...
多线程 (基础)
要学就学灰太狼的博客
12-22 558
1 线程相关概念 1.1 程序(program) 是为了完成特定的功能，用某种语言编写的一组指令集合。简单地说：就是我们写的代码。 1.2 进程 （1）进程是运行中的程序，比如我们使用QQ，就启动了一个进程，操作系统就会为该进程分配内存空间。当我们使用微信，又启动了一个进程，操作系统将为迅雷分配新的内存空间。 （2）进程是程序的一次执行过程，或是正在运行的程序。是动态过程：有它自身的产生/存在和消亡的过程。 1.3 什么是线程 （1）线程是由进程创建的，是一个进程的实体 （2）一个进程可以拥有多个线程
JAVA课程学习第八课：多线程
weixin_45750950的博客
11-08 512
文章目录前言一、线程和进程的联系和区别是什么？二、什么是前台线程，什么是后台线程？三、创建线程有几种方法，它们之间的区别是什么？四、线程的生命周期有哪些状态，哪些方法可以改变这些状态？五、什么是线程安全？为什么会产生线程安全问题？如何解决线程安全问题？六、什么是线程的同步通信？同步通信如何实现？七、什么是死锁？八、如何让某个对象的A方法内的一个代码块和另一个方法B实现同步？九、设计一个程序产生两个线程A与B，B线程执行10秒钟后，被A中止。十、volatile关键字有什么作用?十一、编写Java程序模拟烧水
Java并发编程知识点总结（二）——线程的状态
XHHP
08-31 549
（一）、新建线程的三种方式 继承自Thread类 public class Thread1 { public static void main(String[] args) { Thread thread = new Thread(){ @Override public void run() { ...
Thread 类及常见方法
一朵花花
11-24 1130
Thread 类及常见方法 Thread 的常见构造方法： 方法 说明 Thread( ) 创建线程对象 Thread(Runnable target) 使用 Runnable 对象创建线程对象 Thread(String name) 创建线程对象，并命名 Thread(Runnable target，String name) 使用 Runnable 对象创建线程对象，并命名 举例： // Thread(String name) public class ThreadDem
java线程池参数动态化方案
qq_33879355的博客
01-06 1012
一、锁种类 偏向锁 因为经过HotSpot的作者大量的研究发现，大多数时候是不存在锁竞争的，常常是一个线程多次获得同一个锁，因此如果每次都要竞争锁会增大很多没有必要付出的代价，为了降低获取锁的代价，才引入的偏向锁。 轻量级锁 轻量级锁考虑的是竞争锁对象的线程不多，而且线程持有锁的时间也不长的情景。因为阻塞线程需要CPU从用户态转到内核态，代价较大，如果刚刚阻塞不久这个锁就被释放了，那这个代价就有点得不偿失了，因此这个时候就干脆不阻塞这个线程，让它自旋这等待锁释放。 自旋锁 减少线程上下文切换，提高执行效
用java写两个线程，一个线程打印1-52，另一个线程打印字母A-Z
qq_36291682的博客
12-05 4292
public class test002 {     // 测试     public static void main(String[] args) {         Object obj = new Object();         // 启动两个线程         Thread1 t1 = new Thread1(obj);         Thread2 t2 = new
String字符串去掉头尾的空格
热门推荐
小白学Java
10-21 1万+
String.trim():返回字符串的副本，忽略前导空白和尾部空白。这个是把头尾字符都去掉
达内笔试题——Java基础知识与编程实践
"达内笔试题，包含闭卷考试，API、OOP和基础知识点的考察" 这份笔试题主要针对的是Java编程语言的基础知识，包括API使用、面向对象编程（OOP）以及基本概念。让我们逐一分析每道题目。 1. 题目描述了一个Java程序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值