'''
新增方法：
    爆炸效果的实现
'''
#导入pygame模块
import pygame,time,random
# #pygame官方网站：www.pygame.org
SCREEN_WIDTH=700
SCREEN_HEIGHT=500
BG_COLOR=pygame.Color(0,0,0)
TEXT_COLOR=pygame.Color(255,0,0)
class MianGame():
#主类
    window=None
    my_tank=None
    #定义存储敌方坦克的列表
    enemyTankList=[]
    #初始化敌方坦克的数量
    enemyTankCount=5
    #存储我方坦克的列表
    myBulletList=[]
    #存储敌方子弹的列表
    EnemyBulletList=[]
    #爆炸效果列表
    ExplodeList=[]
    def __init__(self):
        pass

     #开始游戏

    def Startgame(self):
        #加载主窗口
        pygame.display.init()
        MianGame.window=pygame.display.set_mode([SCREEN_WIDTH,SCREEN_HEIGHT])
        #初始化我方坦克
        MianGame.my_tank=Tank(350,250)
        #初始化敌方坦克，并将敌方坦克添加到列表中
        self.creatEnemyTank()
        #设置窗口的标题
        pygame.display.set_caption('坦克大战1.03')


        #设置窗口的填充色
        while True:
            #使用坦克变慢的方法
            time.sleep(0.02)
            #给窗口设置填充色
            MianGame.window.fill(BG_COLOR)
            #获取事件
            self.getEvent()
            MianGame.window.blit(self.getTextSurface('敌方坦克剩余数量%d'%len(MianGame.enemyTankList)),(10,10))
            #调用坦克显示的方法
            MianGame.my_tank.displayTank()
            #循环遍历敌方坦克列表，展示坦克
            self.blitEnemyTank()
            #循环遍历我方坦克的子弹
            self.blitmyBullet()
            # 调用渲染敌方子弹列表的一个方法
            self.blitEnemyBullet()
            #调用移动方法
            #如果坦克的开关是开启，才可以移动
            if not MianGame.my_tank.stop:
                  MianGame.my_tank.move()
                  #调用展示爆炸效果列表的方法
            self.displayExplodes()

            pygame.display.update()

            # 初始化敌方坦克，并将敌方坦克添加到列表中
    def creatEnemyTank(self):
        top=100
        #循环生成敌方坦克
        for i in range(MianGame.enemyTankCount):
            left=random.randint(0,600)
            speed=random.randint(1,4)
            enemy=EnemyTank(left,top,speed)
            MianGame.enemyTankList.append(enemy)

            # 循环遍历敌方坦克列表，展示坦克
    def blitEnemyTank(self):
        for enemyTank in MianGame.enemyTankList:
           if enemyTank.live:
               enemyTank.move()
               enemyTank.randMove()
                #调用敌方坦克射击的方法
               enemyBullet=enemyTank.shot()
                #将敌方子弹存储到子弹列表中
               MianGame.EnemyBulletList.append(enemyTank)
                #如果子弹为NoneType时，不加入到子弹列表
               if enemyBullet:
                    MianGame.EnemyBulletList.append(enemyBullet)
               else:
                    MianGame.enemyTankList.remove(enemyTank)




            # 将敌方子弹加入到窗口中
    def blitEnemyBullet(self):
        for enemyBullet in MianGame.EnemyBulletList:
        # 如果子弹还活着，绘制出来，否则，直接从列表中移除该子弹
            if enemyBullet.live:
                enemyBullet.displayBullet()
                enemyBullet.MoveBullet()
            else:
                MianGame.myBulletList.remove(enemyBullet)
            #循环遍历我方坦克子弹存储列表
        #新增方法：展示爆炸效果列表
    def displayExplodes(self):
        for explode in MianGame.ExplodeList:
            if explode.live:
                explode.displayExlpode()
            else:
                MianGame.ExplodeList.remove(explode)
    def blitmyBullet(self):
        for myBullet in MianGame.myBulletList:
            #如果子弹还活着，绘制出来，否则，直接从列表中移除该子弹
            if myBullet.live:
                myBullet.displayBullet()
                myBullet.MoveBullet()
                myBullet.hitEnemyTank()
            else:
                MianGame.myBulletList.remove(myBullet)

        # 结束游戏
    def Endgame(self):
       print('蟹蟹使用')
       exit()
        #左上角文字的绘制
    def getTextSurface(self,text):
        # 初始化字体模块
        pygame.font.init()
        #查看所有的字体
        #print(pygame.font.get_fonts())
        #获取字体font对象
        font=pygame.font.SysFont('kaiti',18)
        #绘制文字信息
        textSurface=font.render(text,True,TEXT_COLOR)
        return textSurface

        #获取所有事件
    def getEvent(self):
        eventlist=pygame.event.get()
        #遍历事件
        for event in eventlist:
            #判断按下的键是关闭还是键盘按下
            #如果按的是退出，关闭窗口
            if event.type==pygame.QUIT:
                self.Endgame()
            #如果是键盘的按下
            if event.type==pygame.KEYDOWN:
                #判断不同的键盘上、下、左、右
                if event.key == pygame.K_LEFT:
                    #切换方向
                    MianGame.my_tank.direction="L"
                    #修改坦克的开关状态
                    MianGame.my_tank.stop=False
                    #MianGame.my_tank.move()
                    print("向左移动")
                elif event.key == pygame.K_RIGHT:
                    # 切换方向
                    MianGame.my_tank.direction = "R"
                    # 修改坦克的开关状态
                    MianGame.my_tank.stop = False
                    #MianGame.my_tank.move()
                    print("向右移动")
                elif event.key == pygame.K_UP:
                    # 切换方向
                    MianGame.my_tank.direction = "U"
                    # 修改坦克的开关状态
                    MianGame.my_tank.stop = False
                    #MianGame.my_tank.move()
                    print("向上移动")
                elif event.key == pygame.K_DOWN:
                    # 切换方向
                    MianGame.my_tank.direction = "D"
                    # 修改坦克的开关状态
                    MianGame.my_tank.stop = False
                    #MianGame.my_tank.move()
                    print("向下移动")
                elif event.key == pygame.K_SPACE:
                    print('发射子弹')
                    if len(MianGame.myBulletList) < 3:
                        # 创建我方坦克发射的子弹
                        myBullet = Bullet(MianGame.my_tank)
                        MianGame.myBulletList.append(myBullet)
                    else:
                        print('子弹数量不足')
                    print("当前屏幕中的子弹数量为%d"%len(MianGame.myBulletList))
                    #松开方向键，坦克停止移动，修改坦克的移动状态
                    #判断松开的是上、下、左、右键坦克才停止移动
            elif event.type == pygame.KEYUP:
               if event.type == pygame.K_DOWN or event.type == pygame.K_LEFT or event.type == pygame.K_UP or event.type == pygame.K_RIGHT:
                   MianGame.my_tank.stop=True
class BaseItem(pygame.sprite.Sprite):
    def __init__(self):
        pygame.sprite.Sprite.__init__(self)

 #坦克类
class Tank(BaseItem):   #Tank继承BaseItem类，这样就可以继承精灵类中的碰撞算法
    #添加距离左边left，距离上边top
    def __init__(self,left,top):
        #保存加载的图片
        self.images={'U':pygame.image.load('img/p1tankU.gif'),
                     'L': pygame.image.load('img/p1tankL.gif'),
                     'R': pygame.image.load('img/p1tankR.gif'),
                     'D': pygame.image.load('img/p1tankD.gif'),
                     }
        #方向
        self.direction='U'
        #根据当前图片的方向获取图片 surface
        self.image=self.images[self.direction]
        #根据图片获取区域
        self.rect=self.image.get_rect()
        #设置区域的left和top
        self.left=left
        self.top=top
        #速度 决定移动的快慢
        self.speed=5
        #坦克移动的开关
        self.stop=True
        # 子弹的状态,判断子弹是否活着
        self.live = True

    #移动
    def move(self):
       #判断坦克的方向进行移动
       if self.direction=="L":
           if self.rect.left>0:
            self.rect.left-=self.speed
       elif self.direction=="U":
           if self.rect.top>0:    #判断坦克的top值是否大于零，大于零则继续向上移动，否则不能
            self.rect.top-=self.speed
       elif self.direction=="D":
           if self.rect.top+self.rect.height<SCREEN_HEIGHT:  #判断top值加上坦克的高度知否小于窗口的高度
               self.rect.top+=self.speed
       elif self.direction=="R":
           if self.rect.left+self.rect.height<SCREEN_WIDTH:  #判断left值加上坦克的高度知否小于窗口的宽度
               self.rect.left+=self.speed
    #射击
    def shoot(self):
        pass
    #展示坦克的方法
    def displayTank(self):
        #获取展示的对象
       self.image=self.images[self.direction]
        #调用blit方法
       MianGame.window.blit(self.image,self.rect)
    #我方坦克类，继承的是坦克类
class MyTank(Tank):
    def __init__(self):
        pass

    #敌方坦克
class EnemyTank(Tank):
    def __init__(self,left,top,speed):

        #self.live=True
                #加载图片集
        self.images={'U':pygame.image.load('img/enemy1U.gif'),
                     'D': pygame.image.load('img/enemy1D.gif'),
                     'L': pygame.image.load('img/enemy1L.gif'),
                     'R': pygame.image.load('img/enemy1R.gif'),
                     }
        #方向,随机生成敌方坦克的方向
        self.direction=self.randDirection()
        #根据方向获取图片
        self.image=self.images[self.direction]
        #区域
        self.rect=self.image.get_rect()
        #对left和top值进行赋值
        self.rect.left=left
        self.rect.top=top
        #移动开关键
        self.flag=True #flag：标记、标识
        #速度
        self.speed=speed

        #新增加一个步数变量 step
        self.step=20


    # 随机生成敌方坦克的方向
    def randDirection(self):
            num = random.randint(1, 4)  # 随机生成1-4个数，代表不同的方向
            if num == 1:
                return 'U'
            elif num == 2:
                return 'D'
            elif num == 3:
                return 'L'
            elif num == 4:
                return 'R'
        #敌方坦克随机移动的方法
    def randMove(self):
        if self.step<=0:
            #修改方向
            self.direction=self.randDirection()
            #让步数复位，不然步数等于零时，坦克不会移动
            self.step=20
        else:
            self.move()
            #让步数递减
            self.step-=1
    def shot(self):
        num = random.randint(1,100)
        if num == 1:
            return Bullet(self)


    #子弹类
class Bullet(BaseItem):
    def __init__(self,tank):
       #加载图片集
       self.image = pygame.image.load('img/enemymissile.gif')
        #坦克的方向决定子弹的方向
       self.direction=tank.direction
        #获取区域
       self.rect=self.image.get_rect()
        #子弹的left和top值与方向有关
       if self.direction=='U':
            self.rect.left=tank.rect.left+tank.rect.width/2-self.rect.width/2
            self.rect.top=tank.rect.top-self.rect.height
       elif self.direction=='D':
            self.rect.left=tank.rect.left+tank.rect.width/2-self.rect.width/2
            self.rect.top=tank.rect.top+self.rect.height
       elif self.direction=='L':
            self.rect.left=tank.rect.left-tank.rect.width/2-self.rect.width/2
            self.rect.top=tank.rect.top+tank.rect.width/2-self.rect.width/2
       elif self.direction=='R':
            self.rect.left=tank.rect.left+tank.rect.width/2
            self.rect.top=tank.rect.top+tank.rect.width/2-self.rect.width/2

            #子弹的速度
            self.speed=6
            self.live=True

    #移动子弹的方法
    def MoveBullet(self):
       if self.direction == 'U':
          if self.rect.top>0:
              self.rect.top-=self.speed
          else:
             #修改子弹的状态
             self.live=False
       elif self.direction == 'D':
           if self.rect.top<MianGame.SCREEN_HEIGHT-self.rect.height:
               self.rect.top+=self.speed
           else:
               # 修改子弹的状态
               self.live = False
       elif self.direction == 'L':
           if self.rect.left>0:
               self.rect.left-=self.speed
           else:
               # 修改子弹的状态
               self.live = False
       elif self.direction == 'R':
           if self.rect.left<MianGame.SCREEN_WIDTH-self.rect.width:
               self.rect.left+=self.speed
           else:
               # 修改子弹的状态
               self.live = False
    #展示子弹的方法
    def displayBullet(self):
       #将图片surface加载到窗口
       MianGame.window.blit(self.image,self.rect)

    #新增我方子弹碰撞敌方坦克的方法
    def hitEnemyTank(self): #self代表的是我方坦克的子弹
        for enemyTank in MianGame.enemyTankList:
            if pygame.sprite.collide.rect(enemyTank,self):
                #产生一个爆炸效果
                explode =  Explode(enemyTank)   #传入敌方坦克的坐标
                #将爆炸效果加入到爆炸效果列表
                MianGame.ExplodeList.append(explode)
                self.live = False   #说明子弹打中敌方坦克，子弹消亡，状态为False
                enemyTank.live = False  #敌方坦克的状态也为False

    #墙壁类
class wall():
    def __init__(self):
        pass
    #展示墙壁的方法
    def displaywall(self):
        pass

    #爆炸类
class Explode():
    def __init__(self,tank):    #tank代表的是敌方坦克
        self.rect = tank.rect
        self.step = 0
        #加载图片集
        self.images == [
            pygame.image.load('img/blast0.gif'),
            pygame.image.load('img/blast1.gif'),
            pygame.image.load('img/blast2.gif'),
            pygame.image.load('img/blast3.gif'),
            pygame.image.load('img/blast4.gif')
        ]
        self.image == self.images[self.step]
        self.live = True    #给爆炸图片添加一个值，在开始的时候图片是会展示的


    #展示爆炸效果的方法
    def displayExlpode(self):
        #把爆炸图片加载到窗口中
        if self.step < len(self.images):
            MianGame.window.blit(self.image, self.rect)
            self.image=self.images[self.step]   #避免在步数变化后而加载的图片没有变化
            self.step += 1  # 每次产生爆炸的时候，加载的图片是不一样的
        else:
            self.live = False   #爆炸完成之后就不要再展示了
            self.step = 0
    #音效类
class Music():
    def __init__(self):
        pass
    #展示音效的方法
    def displayMusic(self):
        pass

if __name__=='__main__':
      MianGame().Startgame()
      MianGame.getTextSurface()

老师，可以帮我看看问题在哪儿嘛，live属性检查好多遍了，还是不对

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<!--    配置解析properties文件的工具类-->
    <context:property-override location="db.properties"/>
<!--    配置数据源-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
<!--    配置jdbcTemplate-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>
<!--    配置UsersDao-->
    <bean id="usersDao" class="com.bjsxt.dao.impl.UsersDaoImpl">
        <property name="jdbcTemplate" ref="jdbcTemplate"/>
    </bean>
<!--    配置业务层依赖注入-->
    <bean id="usersService" class="com.bjsxt.service.impl.UsersServiceImpl">
        <property name="usersDao" ref="usersDao"/>
    </bean>

老师我的配置文件哪里错了吗？一直报错，实在找不到哪里错了

报错截图：

持久层代码：

public interface UsersDao {
    int insertUsers(Users users);
}

package com.bjsxt.dao.impl;

import com.bjsxt.dao.UsersDao;
import com.bjsxt.pojo.Users;
import org.springframework.jdbc.core.JdbcTemplate;

public class UsersDaoImpl implements UsersDao {
    private JdbcTemplate jdbcTemplate;

    public JdbcTemplate getJdbcTemplate() {
        return jdbcTemplate;
    }

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    /**
     * 添加用户
     * @param users
     * @return
     */
    @Override
    public int insertUsers(Users users) {
        //要执行的sql语句
        String sql = "insert into users values(default,?,?)";
        //要创建一个object数组，来存放sql语句中的参数，参数的名字和位置要一一对应，第一个就是第一个
        Object[]param = new Object[]{users.getUsername(),users.getUsersex()};
        return this.jdbcTemplate.update(sql,param);
    }
}

业务层代码：

public interface UsersService {
    int addUsers(Users users);
}

package com.bjsxt.service.impl;

import com.bjsxt.dao.UsersDao;
import com.bjsxt.pojo.Users;
import com.bjsxt.service.UsersService;

public class UsersServiceImpl implements UsersService {
    private UsersDao usersDao;

    public UsersDao getUsersDao() {
        return usersDao;
    }

    public void setUsersDao(UsersDao usersDao) {
        this.usersDao = usersDao;
    }

    /**
     * 添加用户
     * @param users
     * @return
     */
    @Override
    public int addUsers(Users users) {
        int i = usersDao.insertUsers(users);
        return i;
    }
}

测试层代码：

import com.bjsxt.pojo.Users;
import com.bjsxt.service.UsersService;
import com.bjsxt.service.impl.UsersServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class InsertUsersTest {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        UsersService usersService = (UsersService) applicationContext.getBean("usersService");

        Users users = new Users();
        users.setUsername("wjy");
        users.setUsersex("female");
        int i = usersService.addUsers(users);
        System.out.println(i);
    }
}

pojo代码：

public class Users {
    private int userid;
    private String username;
    private String usersex;

    public int getUserid() {
        return userid;
    }

    public void setUserid(int userid) {
        this.userid = userid;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getUsersex() {
        return usersex;
    }

    public void setUsersex(String usersex) {
        this.usersex = usersex;
    }

    @Override
    public String toString() {
        return "Users{" +
                "userid=" + userid +
                ", username='" + username + '\'' +
                ", usersex='" + usersex + '\'' +
                '}';
    }
}

properties文件：

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/bjsxt
jdbc.username=root
jdbc.password=zjx666888

老师,我照着您敲之后没有出现自己定义的URL,我运行了你的代码也是一样,难道是pycharm版本不同嘛,我的是20版本的

erp项目的启动了启动不起来，提示信息如下，这样应该怎么解决？

问题1：老师，我对重写toString方法中的最后一句，return sb.toSring()不怎么理解，能麻烦详细说下吗？

@Override
public String toString() {
    StringBuilder sb=new StringBuilder();
    sb.append("序号").append("this.id").append("#").append("\t");
    sb.append("姓名").append("this.name").append("\t\t");
    sb.append("年龄").append("this.age").append("\t\t");
    sb.append("性别").append("this.sex").append("\t\t");
    sb.append("电话号码").append("this.telNum").append("\t\t");
    sb.append("地址").append("this.address");
    return sb.toString();

public class Mysinglylinedlist<E> implements My_List<E>{


    /**
     * 定义单向链表中的节点对象
     */
    class Node<E>{
        private E item;//存储元素
        private Node next;//存储下一个节点对象的地址
        Node(E item,Node next){
            this.item=item;
            this.next=next;
        }
    }
    private Node hand;//存放链表中的头节点
    private int size;//记录元素个数


    /**
     * 向链表中添加元素
     * @param element ：添加的元素
     */
    @Override
    public void add(E element) {
        //创建节点
        Node<E>node=new Node<>(element,null);
        //找到尾节点
         Node tail = gettail();
        //挂接
        if(tail==null)
            this.hand=node;
        else
            tail.next=node;

        //记录元素个数
        this.size++;


    }

    private Node gettail(){
    //头节点是否存在
        if(this.hand==null){
            return null;
        }
        //查找尾节点
        Node node = this.hand;
        while (true){
            if (node==null) break;
            node = node.next;     //移动指针指向下一个节点
        }
        return node;
    }


    /**
     * 获取链表中元素
     * @param index ：位置
     * @return
     */
    @Override
    public E get(int index) {
        //效验index的合法性
        this.checkindex(index);
        //根据位置获取指定节点
        Node<E> node = this.getnode(index);
        //将该节点元素返回
        return node.item;
    }


    /**
     *判断index的合法性
     */

    private void checkindex(int index){
        if (!(index>=0&&index<this.size)){
            throw new IndexOutOfBoundsException("Index"+index+"size"+this.size);
        }
    }


    /**
    * 根据位置获取节点
    */
    private Node getnode(int index){
        Node<E> node =this.hand;
        for (int i = 0;i<index;i++){
            node=node.next;
        }
        return node;
    }


    /**
     * 获取链表大小
     * @return
     */
    @Override
    public int size() {
        return this.size;
    }


    /**
     * 根于元素位置删除元素
     * @param index ：元素位置
     * @return
     */
    @Override
    public E remove(int index) {
        //判断位置合法性
        this.checkindex(index);
        //根据位置找到指定节点
        Node<E>node=this.getnode(index);
        //通过节点对象获取该节点对象中的元素
        E item = node.item;
        //将该节点对象从单向链表中移除
        //判断删除的节点是否为头节点
        if (this.hand==node){
            this.hand=node.next;
        }else {
            Node<E> temp = this.hand;
            for (int i = 0;i<index-1;i++){
                temp=temp.next;
            }
            temp.next=node.next;
        }
        node.next=null;
        //元素个数记录
        this.size--;
        //将该元素返回
        return item;
    }

    public static void main(String[] args) {
        Mysinglylinedlist<String>mysinglylinedlist=new Mysinglylinedlist<>();
        mysinglylinedlist.add("a");
        mysinglylinedlist.add("b");
        mysinglylinedlist.add("c");
        mysinglylinedlist.add("d");
        System.out.println(mysinglylinedlist.size);
//        System.out.println(mysinglylinedlist.remove(1));
        for (int i = 0 ; i < mysinglylinedlist.size;i++){
            System.out.println(mysinglylinedlist.get(i) );
        }
    }

为什么会报错啊  

单例模式不可或缺的是什么，__new__起到什么作用

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>小米首页</title>
    <link rel="icon" href="image/favicon.ico">
    <link rel="stylesheet" href="css/reset.css">
    <link rel="stylesheet" href="css/index.css">
</head>
<body>
<!--头部-->
<div class="header">
    <img src="image/bb3c06a430689ba2357dd7d1fbfa6bab.jpg" alt="">
</div>
<!--黑色导航条-->
<div class="header-wrapper">
    <div class="topbar-wrapper">
        <ul class="topbar-nav">
            <li><a href="#">小米商城</a></li>
            <li><a href="#">MUI</a></li>
            <li><a href="#">LOT</a></li>
            <li><a href="#">云服务</a></li>
            <li><a href="#">天星科技</a></li>
            <li><a href="#">有品</a></li>
            <li><a href="#">小爱开放平台</a></li>
            <li><a href="#">企业团购</a></li>
            <li><a href="#">资质证照</a></li>
            <li><a href="#">协议规则</a></li>
            <li><a href="#">下载app</a></li>
            <li><a href="#">智能生活</a></li>
            <li><a href="#">Select Location</a></li>
        </ul>
        <ul class="inf">
            <li><a href="#">登录</a></li>
            <li><a href="#">注册</a></li>
            <li><a href="#">消息通知</a></li>
        </ul>

    </div>
</div>
</body>
</html>


/*头部样式*/
.header{
    width:100%;
    height:120px;
    background-color:red;
    overflow:hidden;
    position:relative;
}
.header img{
    height:120px;
    position: absolute;
    left:50%;
    transform:translateX(-50%);
}
/*黑色导航条*/
.header-wrapper{
    width:100%;
    height:40px;
    background-color: #333333;
}
.topbar-wrapper{
    margin:0 auto;
}
.top-bar{
    width:794.13px;
    height:40px;
    background-color: #cc0000;
    float:left;
}
.topbar-nav li {
    float: left;
}
.topbar-nav a{
    color:#b0b0b0;
    font-size:12px ;
    line-height:40px;
    margin:10px;
}
.inf{
    width:142.48px;
    height:40px;
    background-color: blue;
    float:left;
}
.inf li{
    float:left;
}
.inf a{
    color:#b0b0b0;
    font-size:12px ;
    line-height:40px;

}

截图

两个ul是兄弟元素，给他们设置浮动后应该水平排列，这里蓝色部分为什么是这样能呢？

1. 为什么我圈出来那个地方报错? 要在InputStreamReader前面加java.io.才不会报错.下面的OutputStreamWriter前面不加就不会报错.

2. 那个第一个bw.flush(); 的作用是啥?一开始没有数据传输为什么也要清空管道?
   

老师，为什么我使用表级约束添加唯一约束的运行结果是这样？

老师你好，为啥打印的时候没给我自动创建aa_copy.gif文件并把图片拷贝到里面去呢，究竟是哪一环节出现问题了？

老师，这里的 hθ(x(i)) 为什么到下边就变成了 h(x(i))了，这个θ是怎么消掉的？

a=input("请输入你的月薪：")

b=("你的年薪是:{}")

b.format(int(a)*12)

print(b)

请输入你的月薪：1500

>>> 你的年薪是:{}

#为什么我这样不行？

老师，通过比较器实现比较规则这个显示下面这一行

Map<Student,String> treeMap = new TreeMap<>(new StudentComparator());

出了问题，能帮我看一下是什么问题吗？

package 双例集合;

import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

/**
 * 元素自身实现比较规则   TreeMap可以对键进行排序
 */
public class TreeMapTest {
    public static void main(String[] args) {
        //实例化TreeMap
        Map<Users,String> map = new TreeMap<>();
        //创建User对象
        Users u1 = new Users("liu",18);
        Users u2 = new Users("admin",20);
        Users u3 = new Users("sxt",20);
        map.put(u1,"liu");
        map.put(u2,"admin");
        map.put(u3,"sxt");
        Set<Users> keys = map.keySet();
        for (Users key:keys){
            System.out.println(key+" "+map.get(key));
        }
        System.out.println("-----通过比较器实现比较规则-------");
        //java.lang.ClassCastException: 双例集合.Student cannot be cast to java.lang.Comparable
        //创建StudentComparator对象，然后交给TreeMap的构造方法中
        Map<Student,String> treeMap = new TreeMap<>(new StudentComparator());
        Student s1 = new Student("liu",18);
        Student s2 = new Student("admin",20);
        Student s3 = new Student("sxt",20);
        treeMap.put(s1,"liu");
        treeMap.put(s2,"admin");
        treeMap.put(s3,"sxt");
        Set<Student> keys2 = treeMap.keySet();
        for (Student key:keys2){
            System.out.println(key+" "+treeMap.get(key));
        }

    }
}

老师：return跟print 的主要区别在哪里

我理解的是，有的时候return 跟 print的用法是一样的都可以返回值，但是如果return跟print同时在一个语句里的话，那么return就是赋值，然后Print就是打印，是这样吗