Java学习第八周

伴我所爱

已于 2022-12-10 14:49:59 修改

阅读量161

点赞数

文章标签： java

于 2022-12-10 14:49:58 首次发布

本文链接：https://blog.csdn.net/weixin_53836127/article/details/128265114

版权

1.JDBC原生7大操作步骤

Statement写法

导包
注册驱动

Class.forName("com.mysql.jdbc.Driver");
获取库的连接对象

Connection conn=DriverManager.getConnection("jdbc:mysql://localhost:3306/库名",root,密码);
准备sql语句

String sql="sql语句"；
通过connection连接数据库的执行对象

Statement stmt=conn.createStatement();
执行sql语句

int count =stmt.executeUpdate(sql);
释放资源

stmt.close();

conn.close();

public void add(Employee employee) throws SQLException {
        //获取连接对象
        Connection conn = JdbcUtils.getConnection();
        //sql
        String sql = "insert into employee(name,age,gender,salary,birthday) values('"+employee.getName()+"',"+employee.getAge()+",'"+employee.getGender()+"',"+employee.getSalary()+",'"+employee.getBirthday()+"')" ;
        System.out.println(sql) ;
        //获取执行对象
        Statement stmt = conn.createStatement() ;
        //执行
        int count = stmt.executeUpdate(sql);
        System.out.println(count);
        //释放资源
        JdbcUtils.close(stmt,conn);
    }

封装

构造方法私有,目的就是为了让外界不能new对象

步骤

成员变量声明三个变量
模拟驱动jar包---Driver驱动类---提供静态代码块

1)读取配置文件内容

2)创建一个属性集合列表Properties

3)将1)获取资源文件的输入流对象---加载到属性集合列表中

4)通过key获取value

5)加载驱动类
获取数据库的连接对象
释放资源

public class JdbcUtils {

    //成员变量声明三个变量
    private static String url = null ;
    private static String user = null ;
    private static String password = null ;
    private static String driverClass = null ;

    //模拟 驱动jar包---Driver驱动类---提供静态代码块
    static{
        try {
            //想办法获取这些参数---->提供配置文件  后缀名.properties---->放在src下面
            //1)读取配置文件内容
            InputStream inputStream = JdbcUtils.class.getClassLoader()
                    .getResourceAsStream("jdbc.properties");
            //2)创建一个属性集合列表Properties
            Properties prop = new Properties() ;
            //System.out.println(prop) ;//测试 ---肯定空列表
            //3)将1)获取资源文件的输入流对象---加载到属性集合列表中
            prop.load(inputStream);
           // System.out.println(prop) ; //测试--->有属性列表内容
            //4)通过key获取value
            driverClass = prop.getProperty("driverClass");
            url = prop.getProperty("url") ;
            user = prop.getProperty("user") ;
            password = prop.getProperty("password") ;
            //5)加载驱动类
            Class.forName(driverClass) ;
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }



    private  JdbcUtils(){}


    /**
     * 这个方法,获取数据库的连接对象
     * @return
     */
    public static Connection getConnection(){

        try {
            //需要驱动管理DriverManager获取连接对象
            Connection connection = DriverManager.getConnection(url, user, password);//获取这三个参数的内容
            return connection ;

        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        return  null ;
    }

    /**
     * 释放资源,针对DQL语句操作释放的相关资源对象
     * @param rs
     * @param stmt
     * @param conn
     */
    public static void close(ResultSet rs,Statement stmt,Connection conn){
       if(rs!=null){
           try {
               rs.close();
           } catch (SQLException throwables) {
               throwables.printStackTrace();
           }
       }
        if(stmt!=null){
            try {
                stmt.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if(conn!=null){
            try {
                conn.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
    /**
     * 释放资源,针对DDL语句,DML语句
     * @param stmt
     * @param conn
     */
    public static void close(Statement stmt,Connection conn){
      close(null,stmt,conn);
    }

    public static void main(String[] args) {

        Connection connection = JdbcUtils.getConnection();
        System.out.println(connection);
    }
}

测试工具类

DML

导包/注册驱动
直接获取连接对象JdbcUtils.getConnection()
准备sql语句
获取执行对象conn.createStatement();
执行stmt.executeUpdate(sql);

public class JdbcUtilsTest {
    public static void main(String[] args) {
        Connection conn = null ;
        Statement stmt = null ;
        try {
            //导包/注册驱动
            //直接获取连接对象
            conn = JdbcUtils.getConnection();

            //准备sql语句
            String sql  = "insert into student(name,age,gender,address) values" +
                    "( '高圆圆',20,'女','西安市'),( '张三丰',35,'男','咸阳市'), ( '文章',30,'男','西安市');" ;

            //获取执行对象
            stmt = conn.createStatement();
            //执行
            int count = stmt.executeUpdate(sql);
            System.out.println("影响了"+count+"行") ;

        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            JdbcUtils.close(stmt,conn);
        }

    }
}

DQL

直接获取连接对象JdbcUtils.getConnection();
准备sql语句
获取执行对象conn.createStatement();
执行sql,stmt.executeQuery(sql);
输出信息 while(rs.next()){}
1. 通过列的名称获取 xxx getXXX(String columneLaber)
释放

public class StatementExecuteDQL {
    public static void main(String[] args) throws Exception {
        //1)直接获取连接对象
        Connection conn = JdbcUtils.getConnection();
        //2)准备sql语句
        String sql = "select *  from student" ;
        //3)获取执行对象
        Statement stmt = conn.createStatement();
        //4)执行sql
        ResultSet rs = stmt.executeQuery(sql);
        System.out.println("学生的信息如下:");
        //5)输出信息
        while(rs.next()){
            //通过列的名称获取  xxx getXXX(String columneLaber)
            int id = rs.getInt("id");//第一例的名称
            String name = rs.getString("name");//第二列名称
            int age = rs.getInt("age");//第三列名称
            String gender = rs.getString("gender");//第四列名称
            String address = rs.getString("address");//第五列名称
            System.out.println(id+" "+name+" "+gender+" "+address);
        }
        //释放
        JdbcUtils.close(rs,stmt,conn);
    }
}

练习：查询student表,将每一条数据封装到Student对象中,最终将Student对象添加List集合中

创建一个ArrayList<Student>
JDBC操作---获取连接对象,准备sql,获取执行对象,查询
查询结果--->ResultSet结果集
不断的去封装学生对象,将学生对象,添加集合中
完成遍历

ublic class Test1 {
    public static void main(String[] args) throws Exception {
        //调用一个功能
        List<Student> list =  getAllStudent() ;
        System.out.println("学生信息如下:");
        if(list!=null){
            for(Student s:list){
                System.out.println(s.getId()+"---"+s.getName()+"---"+s.getAge()+"---"+s.getGender()+"---"+s.getAddress());
            }
        }
    }
    //定义通过查询所有学数据,将每一条数据封装学生对象中,最终添加集合中
    public static List<Student> getAllStudent() throws Exception {
        //创建List集合
        List<Student> list = new ArrayList<>() ;
        //JDBC操作
        //获取数据库的连接对象
        Connection conn = JdbcUtils.getConnection();
        //准备sql
        String sql = "select * from student" ;
        //通过连接对象获取执行对象
        Statement stmt = conn.createStatement();
        //执行sql语句
        ResultSet rs = stmt.executeQuery(sql);
        //声明学生类型的变量
        Student s = null ;
        //遍历结果集
        while(rs.next()){
            //封装学生数据
            s = new Student() ;
            //编号
           // int id = rs.getInt("id") ;
          //  s.setId(id) ;
            s.setId(rs.getInt("id") );
            //姓名
            s.setName(rs.getString("name"));
            //年龄
            s.setAge(rs.getInt("age"));
            //性别
            s.setGender(rs.getString("gender"));
            //住址
            s.setAddress(rs.getString("address"));
            //将每一个学生对象添加到list集合中
            list.add(s) ;
        }
        return  list ;
    }

}

单元测试

定义一个功能,没有返回值,没有参数,

在方法上面

@Test标记,它是一个单元测试方法

@Before,标记的方法是在单元测试方法之前先执行

@After,标记的方法是在用单元测试执行之后执行

PreparedStatement原生的写法

1)注册驱动

2)获取数据库的连接对象

3)准备sql-------->参数化sql语句, 这些参数不能在sql写死,都是? 占位符号

4)通过数据库连接对象获取预编译对象,同时将sql发送给数据库,(参数什么类型,第几个参数)都会存储在预编译对象中

5)给参数赋值

6)执行预编译的sql

7)释放资源

public class PreparedStatementDemo {
    public static void main(String[] args) throws SQLException {
        //1)注册驱动
        //  2)获取数据库的连接对象
        Connection conn = JdbcUtils.getConnection();
        //3)准备sql-------->参数化sql语句, 这些参数不能在sql写死,都是?  占位符号
        //给员工表插入数据
        String sql  = "insert into employee(name,age,gender,salary,birthday) values(?,?,?,?,?)" ;
        //4)通过数据库连接对象 获取预编译对象,同时将sql发送给数据库,(参数什么类型,第几个参数)都会存储在预编译对象中
        //Connection--->方法 PreparedStatement prepareStatement(String sql) throws SQLException
        System.out.println(sql) ;
        //interface PreparedStatement extends Statement{}
        PreparedStatement stmt = conn.prepareStatement(sql) ;
        //5)给参数赋值
        //PreparedStatement
        //void setXX(int parameterIndex,XX实际值)throws SQLException
        //参数1:参数化sql里面第几个占位符号 第一个?--->1
        stmt.setString(1,"盲僧") ;
        stmt.setInt(2,20) ;
        stmt.setString(3,"男") ;
        stmt.setInt(4,8000) ;
        stmt.setDate(5,new java.sql.Date(new Date().getTime()));
        //不断进行参数赋值
        //6)通过预编译对象进行参数的赋值的操作
        //int executeUpdate() throws SQLException 通用的更新操作
        //ResultSet executeQuery() throws SQLException 通用的查询操作
        int count = stmt.executeUpdate();
        System.out.println(count);
        //7)释放资源
        JdbcUtils.close(stmt,conn);
    }
}

Statement弊端：执行的是静态sql语句

select * from user where username='helloworld' and password = 'hello 'or '1'='1' 存在sql拼接
SQL注入:用户在输入数据的时候,由于对数据没有充分数据验证,使用了非法sql语句或者指令,恶意攻击数据库!
造成系统不安全,使用预编译对象代替Statement

了有效防止SQL拼接使用的PreparedStatement

SQL注入

通过sql的拼接存在一些问题用户名和密码存在拼接,非常不安全的行为! select * from user where username = 'xxx' and password = 'or 'l'='l';

Statement和PreparedStatement的区别

Statement执行效率相对于PreparedStatement非常低

每次书写一条sql语句就需要通过Statement将sql语句发送给数据库，效率低，同时数据库压力大

发送的sql语句存在字符拼接，会出现安全问题----sql注入，恶意攻击数据库，造成安全漏洞

PreparedStatement提高了sql的执行效率，发送一条参数化的sql，可以不断的重新赋值

由于参数化的sql语句，里面全是占位符号？，不存在拼接，有效防止sql注入

sql指令和JDBC控制事务的方式

sql指令的方式控制事务

1)开启事务 :start transaction ;

2)执行多个sql语句/或者多张表的sql--添加/删除/修改

3)如果有问题,回滚事务 rollback;

4)没有问题,提交事务最终 commit ;

JDBC方式控制事务

java.sql.Connection:

void setAutoCommit(boolean autoCommit) throws SQLException 设置提交模式

参数为false,表示禁用自动提交;为true,默认就是自动提交

void rollback() throws SQLException 事务回滚,撤销之前的所有更新操作; (前提必须处于手动提交)

void commit() throws SQLException 提交事务,将数据永久保存!

数据库连接池 Druid

数据库连接池 Druid 获取连接对象的过程

1）读取连接池的配置文件

InputStream inputStream = Utils.class.getClassLoader().getResourceAsStream("druid.properties");

2）创建属性列表集合

Properties properties=new Properties();

3）将配置文件资源输入流加载属性集合列表中

properties.load(inputStream);

4）创建数据源

DataSource ds= DruidDataSourceFactory.createDataSource(properties);

public class DruidTest {
    public static void main(String[] args) throws Exception {
        //1)导包核心连接池的jar包 druid.jar
        //2)准备了druid.properties配置文件
        //3)创建属性集合列表
        Properties prop = new Properties() ;
        //4)读取src下面的连接池的配置文件
        InputStream inputStream = DruidTest.class.getClassLoader().getResourceAsStream("druid.properties");
        //5)将字节输入流内容加载到属性集合列表中
        prop.load(inputStream);
        //6)从连接池获取连接对象
        //com.alibaba.druid.pool.DruidDataSourceFactory
        //提供了静态方法public static DataSource createDataSource(Properties properties)
        //创建数据源DataSource数据源接口对象---->本质----DruidDataSource实现类
        DataSource ds = DruidDataSourceFactory.createDataSource(prop);
       for(int x = 1;x<=11;x++){
           Connection conn = ds.getConnection();
           if(x == 3){
               conn.close();// 将连接对象归还连接池中
           }
           System.out.println(conn);
       }
    }
}

数据库连接池的作用

1）资源利用重复

使用连接池大大避免了不断地频繁创建连接对象，使用完毕之后，造成资源消耗大

2）提高系统的响应速度

在程序启动的时候，提前准备了足够的连接对象，存储池中，当用户访问比较多的时候，同时应用，可以直接从连接池中取出连接对象，执行速度快

3）控制连接对象

多个连接对象被多个线程在同一时刻使用的时候，连接池中对连接对象进行申请，利用释放，归还连接池中等待下一次利用

针对预编译对象原生操作方式-->引入commons-dbUtils

1）导入核心包

2）创建执行器-----核心执行器：QueryRunner：指定数据源（连接池中核心参数）

3）准备sql语句

4）执行sql----使用反射完成，核心接口ResultSetHandler

QueryRunner qr=new QueryRunner(DruidJdbcUtils.getDataSource())

String sql="";

Employee e=new qr.query(sql,new BeanListHandler<>(Employee.class))//sql语句，测试的接口

public static void main(String[] args) throws SQLException {
        //创建这个执行器
        // public QueryRunner(DataSource ds)  :指定数据源(连接池中核心参数....)
        DataSource dataSource = DruidJdbcUtils.getDataSource();
        QueryRunner qr = new QueryRunner(dataSource) ;
        //准备sql语句
      //  String sql = "select * from employee" ;
        //执行sql
        //  public BeanListHandler(Class<T> type) :参数里面需要当前返回的实体类的字节码文件对象
        //通过员工的id查询员工---查询某个员工
        //String sql = "select * from employee where id  = ?" ;
        //执行sql语句
        //public <T> T query(String sql, ResultSetHandler<T> rsh, Object... params)
        //参数1:sql语句
        //参数2:查询的结果集的处理接口   子实现类BeanHandler---->将查询的某条记录封装到实体类中
        //参数3:SQL语句的参数(赋值的实际参数)
       // Employee employee = qr.query(sql, new BeanHandler<>(Employee.class), 4);
       // System.out.println(employee);
        //查询员工表的记录数
        String sql = "select count(*) from employee" ;
        //public <T> T query(String sql, ResultSetHandler<T> rsh, Object... params)
        //参数1:sql语句
        //参数2:查询的结果集的处理接口   子实现类ScalarHandler--->将查询的结果集处理的时候返回的单行单列的数据
        //参数3:SQL语句的参数(赋值的实际参数)
        Object object = qr.query(sql, new ScalarHandler<>());
        //将Object-- String的valueOf(任何类型数据)--->数字字符串->Integer.parseInt(数字字符串)-->int
        String numbStr = String.valueOf(object);
        int count = Integer.parseInt(numbStr);
        System.out.println(count);
    }

加入Druid连接池的工具类

声明数据源
模拟线程 :每一个线程使用自己的Conneciton
构造方法私有化,外界类不能new
静态代码块

读取src下面的druid.properties配置文件

创建属性集合列表,将配置文件资源输入流加载属性集合列表中

具体子实现类

ds重写赋值DruidDataSourceFactory.createDataSource(prop);
从连接池中获取连接对象

从当前线程获取Conection,,,t1.get();

当前线程中没有连接对象从DataSource连接池获取连接对象ds.getConnection();
释放资源

public class DruidJdbcUtils {
    //声明数据源
    private static DataSource ds  = null ;
    //模拟线程 :每一个线程使用自己的Conneciton
    private static ThreadLocal<Connection> t1 = new ThreadLocal<>();
    //构造方法私有化,外界类不能new
    private DruidJdbcUtils(){}
    //静态代码块
    static{
        try {
            //当前工具类一加载,读取src下面的druid.properties配置文件
            InputStream inputStream = DruidJdbcUtils.class.getClassLoader().
                    getResourceAsStream("druid.properties");
            //创建属性集合列表,将配置文件资源输入流加载属性集合列表中
            Properties prop = new Properties() ;
            prop.load(inputStream) ;
            //通过DruidDataSourceFactory创建DataSource对象---->DruidDataSource具体子实现类
            给ds重写赋值
            ds = DruidDataSourceFactory.createDataSource(prop);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取数据源,就是将配置文件的内容加载到了DataSource
     * @return
     */
    public static DataSource getDataSource(){
        return ds ;
    }
    /**
     * 从连接池中获取连接对象  ---->首先需要创建DataSource接口对象
     * @return
     */
    public static Connection getConnection(){
        try {
            //1)从当前线程获取Conection
            Connection conn = t1.get();
            if(conn==null){
                //2)当前线程中没有连接对象
                //需要从DataSource连接池获取连接对象
                conn  = ds.getConnection();
                //3)将当前连接对象绑定在当前线程上
                t1.set(conn);
            }
            return conn ;
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }

        return  null ;
    }
    //释放资源 针对DQL语句
    public static void close(ResultSet rs, PreparedStatement ps ,Connection conn){
        if(rs!=null){
            try {
                rs.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if(ps!=null){
            try {
                ps.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if(conn!=null){
            try {
                conn.close(); //归还连接池中
                //需要从当前线程ThreadLocal进行解绑
                t1.remove();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }

    /**
     * 针对DDL或者DML语句
     * @param ps
     * @param conn
     */
    public static void close( PreparedStatement ps ,Connection conn){
       close(null,ps,conn);
    }

    //开启事务  ---控制事务:连接对象必须使用同一个!
    public static void setAutoCommit() throws SQLException {
        //从连接池获取连接对象
        Connection conn = getConnection();
        conn.setAutoCommit(false) ; //手动提交
    }

    //回滚事务
    public static void rollBackAndClose() throws SQLException {
        Connection conn = getConnection();
        conn.rollback(); //回滚
        conn.close();
        t1.remove(); //解绑
    }
    //提交事务
    public static void commitAndClose() throws SQLException {
        Connection conn = getConnection();
        conn.commit(); //提交事务
        conn.close();
        t1.remove(); //解绑
    }
    public static void main(String[] args) {
        System.out.println(DruidJdbcUtils.getConnection());
    }
}

HTML : 超文本标记语言(Hyper Text Markup Language)

滚动标签

behavior="滚动方式"

scroll:穿入滚动 alternate:来回滚动 slide 滚动一边停掉

scrollamount ="正整数" 滚动速度

direction ="滚动方向"

left:右--左 right:左--右 down:上--下 up:下--上

bgcolor :背景色

段落标签p

特点:前后两端都携带空行

br:换行标签

列表标签

无序列表ul li

 <ul>
    <!-- type:标记列表前面的内容
        disc:实心圆点
        circle：空心圆点
        square实心正方形-->
    <li>1</li>
    <li>2</li>
</ul>

有序列表ol li

<ol>
 <!-- type="1/A/a/I" -->
    <li>3</li>
    <li>4</li>
</ol>

长引用blockquote

针对文本进行缩进处理，类似于tab

div和span区别

div：块标签后面结合CSS 控制元素,完成网页布局!(层级布局) span:行内标签的作用 (后期用在js表单校验) 在表单项的后面动态提示,校验用户信息是否可用使用行内标签

table表格标签

属性:

border="边框大小指定像素大小" width和height:宽和高(像素/权重百分比) bgcolr:背景色 cellspacing:控制表格边框边框和单元边框之间空隙 align:表格对齐方式

子标签

caption:表格的标题 tr:行标签 th:表头内容,自动居中加粗的效果 td:单元格---理解为列 td单元格的合并列合并:colspan="所占的单元格的数量" 行合并:rowspan="所占的单元格的数量"

表单标签 form

重要的几个属性

action="url地址表单提交的后端地址" method="表单提交方式get/post"

注意

表单项里面所有的必须带name属性,给后端地址标记用户书写的内容!

get提交和post提交的区别:

get提交

1)get提交是将信息数据提交地址栏上 url?key1=value1&key2=value2 2)相对post来说,不适合隐私数据(密码/输入动态密令---加密) 3)get提交到地址栏上,数据大小有限制的!

post提交

1)post提交不会提交到地址栏上,直接在浏览器中F12 ---network网络可以查看到 2)相对get来说,安全一些, (密码/输入动态密令---加密)

权限框架shiro---使用md5加密 (给原始密码上面进行加盐) 3)post提交不会将信息提交地址栏上,所以提交数据大小无限制!

文本输入框

文本输入框
    用户名:<input type="text"  name="username" /><br/>
<!-- 密码输入框,非明文显示 -->
    密码:<input type="password" name="password" /><br/>   
<!-- 单项按钮 radio -->
    性别:
        <input type="radio" value="1" name="sex"  />男
        <input type="radio" value="2" name="sex"  />女<br/>
<!-- 复选框 checkbox -->
    爱好:
            <input type="checkbox" value="1" name="hobby" />足球
            <input type="checkbox" value="2" name="hobby" />篮球
            <input type="checkbox" value="3" name="hobby" />跑步
            <input type="checkbox" value="4" name="hobby" />打游戏
            <br/>
<!-- 文件上传组件file -->
    上传图片:
            <input type="file" name="photo" /><br/>
<!-- 日期组件 date -->
    出生日期:
            <input type="date" name="birthday" /><br/>
<!-- 下列菜单select -->
    籍贯:
            <select name="province">
                <option value="0">请选择</option>
                <option value="1">陕西省</option>
                <option value="2">山西省</option>
                <option value="3">广西省</option>
            </select><br/>
<!-- 文本域textarea 
        rows:文本域的行数
        cols:文本域中一行指定的字符数-->
    自我介绍:
            <textarea rows="2" cols="20">
                我很好,helloworld
            </textarea><br/>
<!-- 普通按钮 -->
            <input type="button" value="添加" />
<!-- 表单提交按钮 -->
            <br/>
            <input type="reset" value="清空" />
            <input type="submit" value="注册" />
<!-- button标签和 input type="submit"都是提交数据-->
<!-- <button>注册</button> -->

a标签target指定打开链接地址的方式

需要结合框架标签中使用,必须指定frame打开 target="frame框架标签的名称"

CSS:层叠样式表

书写的样式是系统样式库中内容

行内样式

单独控制html文档某一个标签 (弊端,只能控制一个) 每一个html标签都有style属性="样式属性名称=值;样式2=值2..."

内部方式

在head标签体中指定style标签,书写样式代码选择器{ 样式属性名称1:值2; ... 样式属性名称n:值n; } 弊端:CSS代码和html标签混合到一块,不利于维护!

外部方式:

单独创建.css文本文件----使用选择器书写代码存储在项目下css文件夹中在当前页面中导入css文件 link标签 href属性="css文件地址" rel="stylesheet" 关联层叠样式表

标签选择器

div{ font-size: 20px; color: aquamarine; }

类选择器 class

在标签中给定class属性,同一个html页面,class属性可以同名类选择器 > 标签名称(元素)选择器 .div1{ font-size: 30px; color: red; }

id选择器

在标签指定id值,id值必须唯一!不能重复 #id属性值{ }

id选择器优先级>class选择器>标签名称选择器 #di1{ text-decoration: underline; color: blue ; }

子元素选择器

选择器1 选择器2... #di1 span{ color: greenyellow; font-size: 15px; }

并集选择器

选择器1,选择器2....

#di1,span,.div1{ font-size: 30px; color: darkgray; text-decoration: underline; }

伪类选择器(锚伪类)

描述元素(标签)的一种状态: link:鼠标没有经过的状态 hover:标经过状态 active:鼠标激活(点击元素,没有松开)的状态 (获取焦点) visited:鼠标访问过的状态(点击并且松开了) 选择器名称:状态名称(不区分大小写){ 控制样式; }

注意事项:

a:hover 必须在 CSS 定义中的 a:link 和 a:visited 之后，才能生效！ a:active 必须在 CSS 定义中的 a:hover 之后才能生效！伪类名称对大小写不敏感。

CSS文本样式,字体样式

text-align:对齐方式 text-align: center;
text-decoration 属性用于设置或删除文本装饰。 text-decoration: underline;
letter-spacing 属性用于指定文本中字符之间的间距。 letter-spacing: 5px;
font-family:字体类型:系统字体库中的字体 font-family: "楷体";
font-size:字体大小指定像素 font-size: 50px;
font-style 属性主要用于指定斜体文本 font-style: italic ;
font-weight:字体粗细程度 bold:适当加粗 font-weight: bold;

边框

本身就有四个边边框颜色 border-color 边框宽度 border-wdith 边框的样式border-style

特点:

默认的方向:上右下左某一边没有设置颜色/宽度/样式,会补齐对边的颜色/宽度和样式边框颜色 border-color :颜色1 颜色2 颜色3 颜色4; 边框宽度border-wdith :宽度1 宽度2 宽度3 宽度4 边框的样式border-style:样式1 样式2 样式3 样式4 (必须指定)

浮动属性float

控制元素向左或者向右浮动,当前这个元素像块框不存在一样,碰到外边框(浏览器)或者其他的块框就停止!

CSS列表样式属性

list-style-type 属性指定列表项标记的类型 circle:空心圆点 squqre:实心正方形 disc:默认值实心圆点 none; 去掉列表项前面的标记 list-style-image 属性规定图像作为列表项标记

CSS背景属性

background-color:背景颜色

background-image:url(图片地址) 如果图片本身尺寸和系统分辨率尺寸不同,图片会重复 background-repeat:设置背景图像是否重复以及如何重复 repeat-x:x轴重复 repeat-y:y轴重复 no-repeat:设置图像不重复 repeat:(默认值)x/y轴都重复(图片本身尺寸和系统分辨率尺寸不同,) background-positon:设置图像的起始位置 top left (默认值) center center bottom right

背景的简写属性

background: background-color background-image background-repeatbackground-position;

position定位属性:

absolute:绝对定位当前这个标签针对父元素进行移动 relative:相对定位当前元素是针对之前的位置进行移动 fixed:固定定位结合left/right/top/bottom---执行像素大小,将整个盒子进行移动

Java中的注解

成为Java标注，被解析应用到程序中

jdk提供内置注解---标记当前一些使用访问

@Override：标记当前这个方法是否重写

@SuppressWarnings：抑制警告，所有的类不能出现黄线

@Deprecated：标记方法过时

@FunctionalInterface：标记接口，是否为函数接口。如果接口中有多个抽象方法，不能使用

内置注解依赖一些"元注解" aTarget:标记指定的注解使用的范围

ElementType[] value(); value属性的返回值枚举类型的数组

ElementType:说明@Target使用的范围〔这四个经常用)

TYPE,标记注解使用类上或者接口上

FIELD,标记注解使用在成员变量上

METHOD，标记这个注解在方法上用

PARAMETER，标记这个注解可以在形参上用

JavaScript

使用方式

1）内部方式：head标签体中，写script标签，书写js代码

2）外部方式:导入js文件

常用的函数：

提示框window.alert("提示框")

向浏览器输出内容document.write("内容")

浏览器控制台打印内容console.log("内容");

带有一个消息和文本输入框window. pprompt("请输入动态密令")

js定义任何变量以及创建文件对象，都使用var（可以省略不写）

JavaScript：弱类型语言，不严谨

数据类型

1）无论是整数还是小数都是number 数值类型提升为js内置对象Number对象

2）boolean类型--提升为内置对象Boolean对象

3）无论是字符还是字符串,都是string类型--提升为内置对象String对象

4）对象object---提升Object代表所有js对象模板

5）未定义类型undefind---没有值

查看js中的变量数据类型typeof(变量名)

var a=10;
var b=3.14;
var c=true;
var d='A';
var e="hello";
var f=new Object();
var g；
document.write("a的数据类型是"+typeof(a));
document.write("b的数据类型是"+typeof(b));
document.write("c的数据类型是"+typeof(c));
document.write("d的数据类型是"+typeof(d));
document.write("e的数据类型是"+typeof(e));
document.write("f的数据类型是"+typeof(f));
document.write("g的数据类型是"+typeof(g));