精华内容
下载资源
问答
  • 面向对象的概括

    2020-08-31 19:54:47
    1.概念 面向对象本质是一种编程范式(一种思考方式) 面向过程:关注是代码实现细节 面向对象:先把代码实现...类是对对象的概括,对象是对类具体实现。 3.构造方法 a.构建对象 b.1.与类同名 2.没有返回值类型

    1.概念

    面向对象本质是一种编程范式(一种思考方式)

    面向过程:关注的是代码的实现细节

    面向对象:先把代码实现细节整合到对象中,找到这个对象就能拥有对象的功能

    面向对象基于面向过程,面向对象优于面向过程?如果场景比较简单优先推荐面向过程,如果场景很复杂优先推荐面向对象
    在这里插入图片描述
    2.对象和类之间的关系

    对一类对象来进行抽取,把共有的特征信息抽取成了属性,把共有的行为信息抽取成了方法,把这一类对象抽取成了类。类是对对象的概括,对象是对类的具体实现。
    在这里插入图片描述
    3.构造方法

    a.构建对象

    b.1.与类同名 2.没有返回值类型

    c.有参构造用于属性初始化,支持构造方法重载

    d.当类中没有定义任何形式的构造方法JVM会在底层默认添加无参构造,如果类中已经定义构造方法那么底层就不会再添加无参构造

    e.类中至少含有一个构造方法

    //当类中没有定义任何形式的构造方法JVM默认在底层会添加无参构造
    
    //当类中定义构造方法底层就不会默认添加无参构造
    
    //无参构造
    
    //1.没有返回值类型2.与类同名
    
    //public Person(){}
    
    //普通方法可以与类同名
    
    //public void Person(){}
    
     
    
    //有参构造---对象属性初始化
    
    //java支持构造方法重载
    
    public Person(Stringname){//方法有就近原则
    
    //this代表当前类的对象
    
    this.name=name;
    
    }
    
    

    注意:java中所有的非静态属性和方法要由对象调用
    4.this

    a.关键字,代表当前类的对象

    b.可以代表当前类还没有产生的对象,代表当前类刚创建的对象,代表当前类正在使用的对象。this是灵活的指代(虚拟),可以指代成当前类正在活动的对象。

    c.this语句—在同一个类中的构造方法里调用别的构造方法,首行

    package cn.tedu.object;
    
     
    
    public classThisDemo{
    
    public static void main(String[]args){
    
    //创建对象
    
    Student s1=new Student();
    
    //this可以代表当前类刚创建对象
    
    System.out.println("s1:"+s1);
    
    //创建对象
    
    Student s2=new Student("tom");
    
    //this是一个灵活的指代
    
    System.out.println("s2:"+s2);
    
    //this指代成当前类正在使用的对象
    
    s1.study();
    
    }
    
    }
    
    //代表学生的类
    
    class Student{
    
    //属性
    
    String name;
    
    int age;
    
    char gender;
    
    //无参构造
    
    public Student(){
    
    System.out.println("this:"+this);
    
    }
    //有参构造
    
    public Student(intage){
    
    this();
    
    }
    
    public Student(Stringname){
    
    //调用别的构造方法
    
    //Student();调用不到
    
    //this语句---调用别的构造方法要在首行
    
    this(1);
    
    this.name=name;
    
    System.out.println("this:"+this);
    
    }
    
    //方法
    
    public void study(){
    
    //this可以代表当前类好没有创建对象
    
    System.out.println(this.name+"在学习...");
    
    //
    
    System.out.println("this:"+this);
    
    }
    }
    
    

    5.构造代码块

    a.在方法外类内{}

    b.属性初始化

    c.优先于所有的构造方法先执行

    package cn.tedu.object;
    
    public class ObjectDemo2{
    
    public static void main(String[]args){
    
    //
    Baby b=new Baby();
    //
    System.out.println(b.name+","+b.age);
    
    }
    }
    //代表婴儿的类--创建对象就是真实的婴儿
    
    //要求:不管怎么出生,婴儿的名字都叫莉莉,年龄是1岁
    
    class Baby{
    
    //属性
    
    String name;
    
    int age;
    
    char gender;
    
    //构造代码块
    
    //优先于所有的构造方法先执行
    
    //属性初始化
    
    {
    
    this.name="莉莉";
    
    this.age=1;
    
    }
    
    //无参构造---婴儿没有名字没有年龄
    
    public Baby(){
    
    /*this.name="莉莉";
    
    this.age=1;*/
    
    }
    
    //有参构造---婴儿出生时有名字
    
    public Baby(String name){
    
    //this.name=name;
    
    /*this.name="莉莉";
    
    this.age=1;*/
    
    }
    
     //婴儿出生时有名字也有年龄
    
    public Baby(String name,int age){
    
    /*this.name=name;
    
    this.age=age;*/
    
    /*this.name="莉莉";
    
    this.age=1;*/
    
    }
    
    //方法
    
    public void cry(){
    
    System.out.println(name+"在嗷嗷的哭...");
    
    }
    
    }
    
    

    6.局部代码块

    a.在方法内{}

    b.控制变量的生命周期,提供内存利用率

    package cn.tedu.object;
    
     
    
    public class ObjectDemo3{
    
    public static void main(String[]args){
    
    int x=1;
    
    //局部(方法)代码块,控制变量的生命周期
    
    {
    
    int y=2;
    
    System.out.println(x+y);
    
    }
    
    //1000行代码没有使用上面定义变量
    
    }
    
    }
    

    7.成员变量与局部变量的区别

    1.位置

    成员变量:方法外类内

    局部变量:方法内

    2.使用范围

    成员变量:整个类

    局部变量:整个方法

    3.内存

    成员变量:堆

    局部变量:栈

    4.生命周期

    成员变量:随着类创建对象而出现,随着对象被回收而消失

    局部变量:当方法被调用时才出现随着方法执行结束而消失

    面向对象的特征

    封装、继承、多态(抽象)

    体现形式—方法,属性私有化并且提供公共的访问方式来进行正常取值和赋值,提高代码数据安全性。

    package cn.tedu.fengzhuang;
    
    public class FZDemo{
    
    public static void main(String[]args){
    
    //创建代表人的类的对象
    
    Person p=new Person();
    
    //给对象属性赋值
    
    //p.name="豆豆";
    
    //调用方法间接给私有化属性进行赋值
    
    p.setAge(-10);
    
    //p.gender='男';
    
    //调用方法间接给私有化属性进行取值
    
    //System.out.println(p.name+","+p.getAge()+","+p.gender);
    
    }
    
    }
    
    //代表人的类
    
    class Person{
    
    //属性
    
    private String name;
    
    //私有化属性,只能在本类中直接使用
    
    private int age;
    
    private char gender;
    
    //Alt+Insert---Generate---GetterandSetter
    
    //java自动提供
    
    public String getName(){
    
    return name;
    
    }
    
    public void setName(Stringname){
    
    this.name=name;
    
    }
    
    public int getAge(){
    
    return age;
    
    }
    
    public void setAge(intage){
    
    this.age=age;
    
    }
    
    public char getGender(){
    
    return gender;
    
    }
    
    public void setGender(chargender){
    
    this.gender=gender;
    
    }
    
    /*//定义方法间接的给私有化属性进行赋值
    
    public void setAge(intage){
    
    if(age<0){
    
    System.out.println("数据有误!!!");
    
    }else{
    
    this.age=age;
    
    }
    
    }
    
     //定义方法间接的给私有化属性进行取值
    
    public int getAge(){
    
    return age;
    
    }*/
    
    /*//有参构造
    
    public  Person(intage){
    
    if(age<0){
    
    System.out.println("数据有误!!!");
    
    }else{
    
    this.age=age;
    
    }
    
    }*/
    
    }
    

    继承

    概念
    如果多个类的内容出现重复,把重复的内容放到一个新的类中,通过extends关键字让原来的类和新的类产生关联关系—继承。原来的类是子类,新的类是父类。子类可以继承父类部分信息(父类的私有化信息、构造方法以及构造代码块不能被继承)。

    packagecn.tedu.extendsx;
    
     
    
    public class ExtendsDemo1{
    
    public static void main(String[]args){
    
    //创建子类对象---医生类对象
    
    Doctor d=new Doctor();
    
    d.treat();
    
    }
    
    }
    
    //定义医疗人员类
    
    //基类、超类、父类
    
    class医疗人员{
    
    //属性
    
    String name;
    
    int age;
    
    char gender;
    
    //科室
    
    String dept;
    
    //方法
    
    public void treat(){
    
    System.out.println(name+"在治病救人...");
    
    }
    
    }
    
    //定义代表医生的类
    
    //通过extends关键字让两个类之间产生关联关系----继承
    
    //派生类、子类
    
    class Doctor extends 医疗人员{
    
    public void treat(){
    
    System.out.println(name+"拿着手术刀在治病救人...");
    
    }
    
    }
    
    //代表护士的类
    
    class Nurse extends 医疗人员{
    }
    
    

    继承方式(单继承)

    子类只能有一个父类,一个父类可以有多个子类

    Class A extends B{} class B extends C{} class C{}(多级继承)

    重写(覆盖)

    在父子类中出现方法签名一致的方法称之为重写 遵守重写原则(两等两小一大)

    方法签名一致(前提)

    当父类方法返回值类型是基本类型/void时那么子类方法返回值类型要和父类方法返回值类型保持一致

       class A{
                public int m(){return 1;}
                 }
    
       class B extends A{
    
                public int m(){return 2;}
                }
    

    当父类方法返回值类型是引用类型时,那么子类方法返回值类型要么和父类方法返回值类型一致要么是父类方法返回值类型的子类

    class A{}
    
    class B extends A{}
    
    class C{
    
    public A m(){return null;}
    
    }
    
    class D extends C{
    
    public A/B m(){return null;}
    
    }
    
    

    子类方法访问权限修饰符要么和父类方法访问权限修饰符范围一致要么比父类方法访问权限修饰符的范围要大

    class A{
    
     void m(){}
    
    }
    
    class B extends A{
    
    public void m(){}
    
    }
    
    
    

    访问权限修饰符—控制在哪个位置关系(定义信息地方和获取信息的地方产生四种位置关系—本类、同包类、其他类、子类)下可以获取定义的信息
    在这里插入图片描述
    super
    a.关键字,代表父类对象

    b.super语句—在子类构造方法里调用父类构造方法 首行使用

    c.每个子类构造方法里默认调用父类无参构造,如果父类没有提供无参构造需要每个子类构造方法里手写super有参调用对应的父类有参构造

    d.父类对象优先于子类对象先出现

    e.父子类执行顺序(对象级别)—父类构造代码块-父类构造方法-子类构造代码块-子类构造方法

    package cn.tedu.extendsx;
    
    publi cclass Extends Demo3{
    
    public static void main(String[]args){
    
    //创建子类对象
    
    Pig p=new Pig(1);
    
    //p.eat();
    
    }
    
    }
    //定义代表动物的类
    
    class Animal{
    
    //父类构造方法
    
    /*public Animal(){
    
    System.out.println("父类无参构造");
    
    }*/
    
    public Animal(String s){
    
    }
    
    public void eat(){
    
    System.out.println("在吃东西...");
    
    }
    
    public void sleep(){
    
    System.out.println("在睡觉...");
    
    }
    
    }
    
    //定义代表猪的类
    
    class Pig extends Animal{
    
    //父类对象优先于子类对象先出现
    
    //子类无参光构造
    
    //子类所有的构造方法中都有默认调用父类的无参构造
    
    //如果父类没有提供无参构造,每个子类构造方法都要手写super有参语句调用父类有参构造
    
    public Pig(){
    
    //super语句---调用父类构造方法,要在首行
    
    super("sd");
    
    System.out.println("子类无参构造");
    
    }
    
    public Pig(inti){
    
    //
    
    super("123");
    
    System.out.println("子类有参构造");
    
    }
    
    //重写eat方法
    
    public void eat(){
    
    System.out.println("在无忧无虑的吃东西。。。");
    
    System.out.println("吃着吃着吃饱了。。。想睡觉。。。");
    
    //java中所有的非静态方法与属性都需要通过对象调用
    
    //this?代表当前类的对象
    
    //super代表父类"对象"可以调用父类里的信息
    
    super.sleep();
    
    }
    
    }
    
    

    多态

    概念
    代码执行过程中呈现的多种形式

    java分为编译时期、运行时期

    编译时多态—在编译时期绑定代码 体现形式—重载

    public void m(){…}

    public void m(int i){…}

    运行时多态—在运行时期绑定代码 体现形式—重写、向上造型(继承)

    向上造型
    可以调用哪些方法看父类,方法的具体执行看子类(父类—目录 子类—正文)

    package cn.tedu.duotai;
    
    public class DTDemo{
    
    public static void main(String[]args){
    
    /*//养个宠物
    
    Pet p;
    
    //养的宠物就是一条狗
    
    p=new Dog();*/
    
    //左边声明类是父类,右边实际创建类是子类---向上造型
    
    Pet p=new Dog();
    
    //向上造型对象可以调用哪些方法看父类
    
    //方法的具体执行要看子类是否有重写方法
    
    p.eat();
    
    //调用方法
    
    //匿名对象是当做参数来传递
    
    m(new Pet());
    
    m(new Dog());
    
    m(new Cat());
    }
    
    //可以接收本类对象以及所有的子类对象
    
    public static void m(Pet p){//=new Pet();=new Dog();=new Cat();
    
    p.eat();
    
    }
    
    }
    
    //定义代表宠物的类
    
    class Pet{
    
    public void eat(){
    
    System.out.println("在吃东西。。。");
    
    }
    
    public void sleep(){
    
    System.out.println("在睡觉。。。");
    
    }
    
    }
    
    //定义代表狗的类
    
    class Dog extends Pet{
    
    //重写eat方法
    
    public void eat(){
    
    System.out.println("在呼哧呼哧的吃。。。");
    
    }
    
    public void brak(){
    
    System.out.println("在汪汪汪的叫。。。");
    
    }
    
    }
    
    //定义代表猫的类
    
    class Cat extends Pet{
    
    //重写eat方法
    
    public void eat(){
    
    System.out.println("在呼哧呼哧的吃。。。");
    
    }
    
    public void 磨爪子(){
    
    System.out.println("在哼哧哼哧的磨爪子。。。");
    
    }
    
    }
    
    

    解释重写原则(反证法)
    1.子类方法访问权限修饰符要么和父类方法访问权限修饰符范围一致要么大于父类的方法访问权限修饰符的范围

    class A{
    
    public void m(){}
    
    }
    
    class B extends A{
    
    void m(){}
    
    }
    

    A a=new B();//向上造型,声明类是A类可以调用A类里m方法,表面这个m方法可以在任意位置被调用。

    a.m();//向上造型对象调用方法具体执行看子类是否有重写方法,执行B类里的m方法,表面m方法同包范围内被调用。此时前后有矛盾,代码错误的

    2.当父类方法返回值类型是引用类型时,那么子类方法返回值类型要么和父类方法返回值类型一致要么是父类方法返回值类型的子类

    class A{
    
    }
    
    class B extends A{}
    
    class C{
    
    public B m(){return null;}
    
    }
    
    class D extends C{
    
    public A m(){return null;}
    
    }
    

    C c=new D();//向上造型对象c,调用声明类C类m方法返回B类对象可以获取B类里信息。

    A a=c.m();//向上造型执行具体方法看子类D类,调用D类里m方法返回A类对象a,由a对象可以获取A类里信息。此时前后矛盾,证明代码是错误的

    多态优点
    1.统一参数类型
    2.降低耦合度(高内聚、低耦合)

    展开全文
  • 实际上,命令用法并不难,例如 mkdir、touch和 find 也分别可以简单概括为“建立新目录”、“更新文件”和“在目录树中查找文件”而已。 但如果要理解 mkdir test_dir 2>/dev/null || touch images.txt &&...

    掌握连接各个命令之间的连接符号用法也是很重要的。实际上,命令的用法并不难,例如 mkdir、touch和 find 也分别可以简单概括为“建立新目录”、“更新文件”和“在目录树中查找文件”而已。

    但如果要理解

    mkdir test_dir 2>/dev/null || touch images.txt && find . -iname "*jpg" > backup/dir/images.txt &
    这一串命令的目的,以及为什么要这样写,就没有这么简单了。

    关键之处就在于命令之间的连接符号。掌握了这些符号的用法,不仅可以让你更好理解整体的工作原理,还可以让你知道如何将不同的命令有效地结合起来,提高工作效率。

    在这一篇文章和接下来的文章中,我会介绍如何使用 & 号和管道符号(|)在不同场景下的使用方法。

    幕后工作
    我来举一个简单的例子,看看如何使用 & 号将下面这个命令放到后台运行:

    cp -R original/dir/ backup/dir/
    这个命令的目的是将 original/dir/ 的内容递归地复制到 backup/dir/ 中。虽然看起来很简单,但是如果原目录里面的文件太大,在执行过程中终端就会一直被卡住。

    所以,可以在命令的末尾加上一个 & 号,将这个任务放到后台去执行:

    cp -R original/dir/ backup/dir/ &
    任务被放到后台执行之后,就可以立即继续在同一个终端上工作了,甚至关闭终端也不影响这个任务的正常执行。需要注意的是,如果要求这个任务输出内容到标准输出中(例如 echo 或 ls),即使使用了 &,也会等待这些输出任务在前台运行完毕。

    当使用 & 将一个进程放置到后台运行的时候,Bash 会提示这个进程的进程 ID。在 Linux 系统中运行的每一个进程都有一个唯一的进程 ID,你可以使用进程 ID 来暂停、恢复或者终止对应的进程,因此进程 ID 是非常重要的。

    这个时候,只要你还停留在启动进程的终端当中,就可以使用以下几个命令来对管理后台进程:

    jobs 命令可以显示当前终端正在运行的进程,包括前台运行和后台运行的进程。它对每个正在执行中的进程任务分配了一个序号(这个序号不是进程 ID),可以使用这些序号来引用各个进程任务。

    $ jobs[1]- Running cp -i -R original/dir/ backup/dir/ &[2]+ Running find . -iname "jpg" > backup/dir/images.txt &
    fg 命令可以将后台运行的进程任务放到前台运行,这样可以比较方便地进行交互。根据 jobs 命令提供的进程任务序号,再在前面加上 % 符号,就可以把相应的进程任务放到前台运行。

    $ fg %1 # 将上面序号为 1 的 cp 任务放到前台运行
    cp -i -R original/dir/* backup/dir/
    如果这个进程任务是暂停状态,fg 命令会将它启动起来。

    使用 ctrl+z 组合键可以将前台运行的任务暂停,仅仅是暂停,而不是将任务终止。当使用 fg 或者 bg 命令将任务重新启动起来的时候,任务会从被暂停的位置开始执行。但 sleep 命令是一个特例,sleep 任务被暂停的时间会计算在 sleep 时间之内。因为 sleep 命令依据的是系统时钟的时间,而不是实际运行的时间。也就是说,如果运行了 sleep 30,然后将任务暂停 30 秒以上,那么任务恢复执行的时候会立即终止并退出。
    bg 命令会将任务放置到后台执行,如果任务是暂停状态,也会被启动起来。

    $ bg %1
    [1]+ cp -i -R original/dir/* backup/dir/ &
    如上所述,以上几个命令只能在同一个终端里才能使用。如果启动进程任务的终端被关闭了,或者切换到了另一个终端,以上几个命令就无法使用了。

    如果要在另一个终端管理后台进程,就需要其它工具了。例如可以使用 kill 命令从另一个终端终止某个进程:

    kill -s STOP <PID>
    这里的 PID 就是使用 & 将进程放到后台时 Bash 显示的那个进程 ID。如果你当时没有把进程 ID 记录下来,也可以使用 ps 命令(代表 process)来获取所有正在运行的进程的进程 ID,就像这样:

    ps | grep cp
    执行以后会显示出包含 cp 字符串的所有进程,例如上面例子中的 cp 进程。同时还会显示出对应的进程 ID:

    $ ps | grep cp
    14444 pts/3 00:00:13 cp
    在这个例子中,进程 ID 是 14444,因此可以使用以下命令来暂停这个后台进程:

    kill -s STOP 14444
    注意,这里的 STOP 等同于前面提到的 ctrl+z 组合键的效果,也就是仅仅把进程暂停掉。
    如果想要把暂停了的进程启动起来,可以对进程发出 CONT 信号:

    kill -s CONT 14444
    这个给出一个可以向进程发出的常用信号列表。如果想要终止一个进程,可以发送 TERM 信号:
    kill -s TERM 14444
    如果进程不响应 TERM 信号并拒绝退出,还可以发送 KILL 信号强制终止进程:
    kill -s KILL 14444
    强制终止进程可能会有一定的风险,但如果遇到进程无节制消耗资源的情况,这样的信号还是能够派上用场的。
    另外,如果你不确定进程 ID 是否正确,可以在 ps 命令中加上 x 参数:

    $ ps x| grep cp
    14444 pts/3 D 0:14 cp -i -R original/dir/Hols_2014.mp4
    original/dir/Hols_2015.mp4 original/dir/Hols_2016.mp4
    original/dir/Hols_2017.mp4 original/dir/Hols_2018.mp4 backup/dir/
    这样就可以看到是不是你需要的进程 ID 了。

    最后介绍一个将 ps 和 grep 结合到一起的命令:

    $ pgrep cp
    8
    18
    19
    26
    33
    40
    47
    54
    61
    72
    88
    96
    136
    339
    6680
    13735
    14444
    pgrep 可以直接将带有字符串 cp 的进程的进程 ID 显示出来。

    可以加上一些参数让它的输出更清晰:

    $ pgrep -lx cp
    14444 cp
    在这里,-l 参数会让 pgrep 将进程的名称显示出来,-x 参数则是让 pgrep 完全匹配 cp 这个命令。如果还想了解这个命令的更多细节,可以尝试运行 pgrep -ax。

    总结
    在命令的末尾加上 & 可以让我们理解前台进程和后台进程的概念,以及如何管理这些进程。

    在 UNIX/Linux 术语中,在后台运行的进程被称为守护进程daemon。如果你曾经听说过这个词,那你现在应该知道它的意义了。

    和其它符号一样,& 在命令行中还有很多别的用法。在下一篇文章中,我会更详细地介绍。

    转载于:https://blog.51cto.com/14164498/2363446

    展开全文
  • 一淘点评情感分析方法及应用场景

    千次阅读 2013-10-25 13:33:42
    2013-10-23 ...基于情感分析结果,可以更加有效过滤、筛选、排序、概括和展现点评内容,方便用户对点评信息使用;基于情感分析结果,还可以在语义维度实现产品聚合、相关性计算,协助用户购物决策。

    2013-10-23 水德 阿里技术嘉年华

        点评是非常重要的一类UGC数据,里面含有大量的用户反馈信息。点评情感分析(sentiment analysis)负责对点评进行情感信息的抽取、聚合和应用。基于情感分析结果,可以更加有效的过滤、筛选、排序、概括和展现点评的内容,方便用户对点评信息的使用;基于情感分析结果,还可以在语义维度实现产品的聚合、相关性计算,协助用户购物决策。



     一、情感分析入门


         按照Bing Liu教授【1】的观点,情感分析可以作如下形式化定义:

    其中,

            


    用一句通俗的话来说明,就是:


    “什么人在什么时间对什么东西的哪一方面表达了怎样的情感”


    举个例子,对于如下的点评:


    情感分析的结构化结果如下:


    {APPLE/苹果 IPHONE 4S(16G) IOS 手机, 信号, 不是很好, tztty, 2012-11-05}

     

    二、几个关键概念


        对于一淘点评情感分析来说,上面定义的五个维度信息中,“评价的对象”就是评论所挂的商品或产品(当然,由于我们目前默认评论都是针对它所挂的商品而发,没有考虑评论中涉及其他商品的情况),“发表评论者”和“评论发表的时间”也都很容易获取。所以最重要的就是要知道“评价对象的具体哪一方面”以及“评论的情感极性”,从词典挖掘角度看,其中“评价对象的具体哪一方面”对应的是“属性词”,“评论的情感极性”对应的是“情感词”。

     

    1. 属性提示词

          

     属性就是评价中的评价方面,对于产品来说,

           

    (1)一个产品,它本身由很多部件构成,比如iPhone4s手机这个产品,它由屏幕、电池、内存、CPU、外壳等等部件组成;

           

    (2)对于iPhone4s本身,它有很多属性(attribute),比如价格、质量、性价比等等;

            

    (3)对于iPhone4s的每一个部件,也有很多属性(attribute),比如对于屏幕,它的属性有大小、颜色、分辨率等等。

    对此,对于一个产品,我们可以用一个树状图来表示:         


        对于商品而言,可以再加上一些像卖家服务相关的、物流相关的等属性。以上这些词都是属性提示词。

     

    2. 属性词


        价格这个属性,在点评中会有不同的表达形式,比如:价格、价位、价钱、售价、价等等;外观这个属性,在点评中也会有不同的表达形式,比如:外观、外形、样子、外型、机身、样式、款式、造型等等。


        这些描述属性的具体词,就是上面说的属性提示词的概念。把这些描述同一个概念的属性提示词映射到一个词上,这个新词就是属性词。比如,可以把外观、外形、样子、外型、机身、样式、款式、造型这些属性提示词归一化为一个属性词”外观“。



    3. 情感词

     

        情感词是指用户用来表达情感的词,简单可以分为褒义词、贬义词。比如,“好”、“不错”、“漂亮”、“时尚”、“便宜”等。情感词需要进行正负极性标注,正面情感词即是褒义词,负面情感词即是贬义词。

     

    三、一淘点评情感分析方法


            除了属性提示词词典、属性词词典、情感词词典之外,还需要否定词词典、程度副词词典。否定词词典进行情感极性的翻转,程度副词词典进行情感强度的加权。


            整个情感分析的过程,可以简化为抽取<属性提示词,情感词>这样的结构对的过程。整个过程如下图所示:

     

     


        这里需要解释的是,对于<属性提示词,情感词>这种结构对(比如<外观,漂亮>),在有些情况下,由于情感词本身就能表明它所要描述的属性,因此属性提示词会被省略掉,比如,”便宜“,大家都知道在说”价格“,很多情况下,”价格“这个词就省略了。所以就会出现<, 情感词>这种只有情感词的情况。

     

    四、一淘点评情感分析应用


            对点评做情感分析后,这种结构化、标签化的结果,可以在很多地方应用。比如:


    1. 标签展现



    2. 点评筛选


           对于上面的标签,当用户点击后,可以把包含这个标签内容的点评筛选出来。


    3. 点评排序


           用点评的情感分析结果,作为评价点评质量的一个重要维度,从而影响点评的展现顺序。


    4. 影响产品/商品排序


            可以把一个产品/商品的所有点评的情感分析结果进行汇总,然后或者把整个结果打成一个分数来影响产品/商品排序,也可以只根据某个属性维度来对产品/商品进行排序。比如,对于某款化妆水,当用户点击了”保湿效果好“这个标签后,可以把所有的化妆水按照保湿效果的情感得分情况进行排序并推荐给用户。


    参考文献:

    【1】Bing Liu,Web Data Mining


    --

    微信名称:阿里技术嘉年华

    微信号:alibabatech

    简介:传播原创高质量的技术内容


    展开全文
  • Java泛型使用场景

    千次阅读 2019-08-06 11:00:37
    泛型本质是参数化类型,也就是说所操作数据类型被指定为一个参数方式传递,类似于方法变量参数。可以用在类、接口、方法的创建中,分别简称为泛型类、泛型接口、泛型方法。 在没有使用泛型情况下,...

    一、泛型概括

             泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数的方式传递,类似于方法中的变量参数。可以用在类、接口、方法的创建中,分别简称为泛型类、泛型接口、泛型方法。

              在没有使用泛型的情况下,如果要实现参数“任意化”,通常会定义成Object类型来接受,然后强制类型转换使用;而强制类型转换有明显的缺点,就是必须要知道实际参数的具体类型的情况才可以进行转换,同时在强制转换的过程中,编译器不会报错提示的,只有在运行阶段才会出现异常,一定程度上存在安全隐患。

    二、泛型的使用

               泛型的使用方式,可以在类、接口、方法中使用,分别简称之泛型类、泛型接口、泛型方法,并且通过泛型实现数据类型的任意化,即灵活、又有安全性,易于维护。

    注:

            JDK在编译之后程序会采取去泛型化的措施。也就是说Java中的泛型,只在编译阶段有效。在编译过程中,正确检验泛型结果后,会将泛型的相关信息擦出,并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。也就是说,泛型信息不会进入到运行时阶段。

    三、类型通配符

    类型通配符就是匹配任意类型的形参。

        类型通配符是一个问号(?),将一个问号作为类型形参传递给List集合,写作:List<?>,(意思是元素类型未知的List)。

    这个问号(?)被成为通配符,它的元素类型可以匹配任何类型。

    例子:

    public void test(List<?> c){
      for(int i =0;i<c.size();i++){
        System.out.println(c.get(i));
      }
    }
    调用:
    
    List<String> list = new ArrayList<String>();
    list.add("333");
    List<Integer> list2 = new ArrayList<Integer>();
    list2.add(3334);
    test(list);
    test(list2);


    上限通配符
         如果想限制使用泛型类别时,只能用某个特定类型或者是其子类型才能实例化该类型时,可以在定义类型时,使用extends关键字指定这个类型必须是继承某个类,或者实现某个接口,也可以是这个类或接口本身。

    //它表示集合中的所有元素都是Shape类型或者其子类
    List<? extends Shape>


        这就是所谓的上限通配符,使用关键字extends来实现,实例化时,指定类型实参只能是extends后类型的子类或其本身。

    下限通配符
    如果想限制使用泛型类别时,只能用某个特定类型或者是其父类型才能实例化该类型时,可以在定义类型时,使用super关键字指定这个类型必须是是某个类的父类,或者是某个接口的父接口,也可以是这个类或接口本身。

    //它表示集合中的所有元素都是Circle类型或者其父类
    List <? super Circle>


       这就是所谓的下限通配符,使用关键字super来实现,实例化时,指定类型实参只能是extends后类型的子类或其本身。

    四、类型擦除
    例子:

    Class c1=new ArrayList<Integer>().getClass();
    Class c2=new ArrayList<String>().getClass();
    System.out.println(c1==c2);


    输出:

    true


       这是因为不管为泛型的类型形参传入哪一种类型实参,对于Java来说,它们依然被当成同一类处理,在内存中也只占用一块内存空间。从Java泛型这一概念提出的目的来看,其只是作用于代码编译阶段,在编译过程中,对于正确检验泛型结果后,会将泛型的相关信息擦出,也就是说,成功编译过后的class文件中是不包含任何泛型信息的。泛型信息不会进入到运行时阶段。

    五、总结

       科普一下,jdk是1.5开始就推出了泛型一说,作为jdk1.5的新特性,在1.5之前jdk都是通过object来进行强制转换的。

        另外,一提到泛型,相信大家用到最多的就是在集合中,其实,在实际的编程过程中,自己可以使用泛型去简化开发,且能很好的保证代码质量,例如调第三方接口的返回类型,在接口返回接受对象泛型化,有利用程序的扩展和可维护性等,以及Json在做数据转换成实体对象时就可以去通过泛型做Util。

     

     

     

     

    展开全文
  • SeniorUI_高级UI汇总目录 自定义控件一般分为三类:继承控件、自绘控件、组合控件 可以直接看第四部分: 自定义控件onMeasure的常见...在原有基础上 添加特定场景的产品功能。 1 Demo public class ASpecImageView ...
  • 目的 相信在网上都有很多的Array的api介绍 , 这里就应用场景举例说明 ... 一句话概括:用别人的方法,完成自己的功能。 function Student(name,gender,age){ this.name = name; this.gender = gende...
  • 1、Map的概括总结 (01) Map 是“键值对”映射抽象接口。(02) AbstractMap 实现了Map中绝大部分函数接口。它减少了“Map实现类”重复编码。(03) SortedMap 有序“键值对”映射接口。(04) NavigableMap 是...
  • 各个JAVA场景内存图

    千次阅读 2017-07-31 17:13:12
    首先,内存模型图,如下: 其次,一句话概括各个区域作用: 1:程序计数器(Program Counter Register),让虚拟机中字节码解释器通过改变计数器值来获取下一条代码指令,比如分支、循环、跳转、异常处理、...
  • 解析:当static修饰完内部类以后,内部类的创建就不在需要外部类实例化对象来调用创建,只需要通过staticTest.InnerClass() 的方法就可以调用。 (2)static 修饰方法 修饰方法的时候,和修饰类一样,...
  • 文章目录概括细分 概括 CountDownLatch : 一个线程(或者多个), 等待另外N个线程完成某个事情之后才能执行。 CyclicBarrier : N个线程相互等待,任何一个线程完成之前,所有线程都必须等待。 细分 ...
  • 对象&继承小概括

    2020-12-22 01:13:25
    对象 什么时候必须使用['属性名']方式?... * 套路: 先创建空Object对象, 再动态添加属性/方法 * 适用场景: 起始时不确定对象内部数据 * 问题: 语句太多 - 字面量创建对象 * 套路: 使用{}创建对象, 同时...
  • 大数据应用价值发现三大方法 关于大数据讨论,一方面人们需要厘清大数据概念,开发适用大数据系统和工具,探索大数据应用模式等,另一方面人们更关心如何将大数据价值变现。这对于一个企业来说尤其重要...
  • vue keep-alive应用场景及如何使用

    千次阅读 2020-07-16 17:45:56
    一、应用场景: 在开发中经常有从列表跳到详情页,然后返回详情页时候需要缓存列表页原来数据以及滚动位置,这个时候就需要保存状态,要缓存状态。概括来讲: 1、列表页面 ——进入详情页 —— 后退到列表页...
  • 知识整理八种笔记方法

    千次阅读 2019-04-29 11:40:03
    文章最后总结了几种笔记方法的应用场景及逻辑顺序 康奈尔笔记法 适用情况:课堂笔记、读书笔记 如图,将笔记本分为三部分:线索栏、笔记栏、总结栏 1. 记录(Record):在笔记栏内尽量多既有意义论据、概念等内容 2...
  • Java学习之泛型及应用场景

    千次阅读 2018-05-23 22:49:31
    一、概括泛型本质是参数化类型,也就是说所操作数据类型被指定为一个参数方式传递,类似于方法变量参数。可以用在类、接口、方法的创建中,分别简称为泛型类、泛型接口、泛型方法。在没有使用泛型情况下...
  • 为了简化三维建筑群模型,提出了一种基于视觉认知理论聚类概括方法。 该方法使用道路要素对场景进行粗略划分,然后使用方向,面积,高度及其拓扑约束等空间认知要素对其进行精确分类,以使其符合城市形态特征。 ...
  • ThreadLocal 用途与使用场景

    千次阅读 2019-07-04 10:23:37
    概括起来说,对于多线程资源共享问题,同步机制采用了“以时间换空间”方式,而 ThreadLocal 采用了“以空间换时间”方式。前者仅提供一份变量,让不同线程排队访问;后者为每一个线程都提供了一份变量,...
  • 你每天在看各种产品干货分享时,是不是经常看到一...既然是主观感受,那么就受限于使用者本身特性(目标群体)、使用场景等因素。并且,“主观感受”一词暗示着,很多时候用户并不知道自己真实、客观需求是什么
  • 思考一个问题:高并发的场景都喜欢用Kafka做中间件,为什么? 答:消息解耦需要用中间件,Kafka有几点优势: 1. 底层消息传递(FileChannel.transferTo API) 运用到Zero-Copy技术,简单概括就是减少数据从内核空间...
  • 所提出体系结构不仅能够估计车辆或行人等常见道路参与者运动,而且可以概括为训练数据中不存在其他对象类别。还将对不同时间上下文聚合策略(例如循环单元和3D卷积)进行深入分析。 最后,多提出最新模型...

空空如也

空空如也

1 2 3 4 5 ... 13
收藏数 246
精华内容 98
关键字:

概括场景的方法