精华内容
下载资源
问答
  • 包(package)是Java提供的一种区别类的名字空间的机制,是类的组织方式,是一组相关类和接口的集合,它提供了访问权限和命名的管理机制。 Java中提供的包主要有以下3种用途:  1) 将功能相近的类放在同一个包中,...

    原则上一个软件对应一个进程。
    多进程:在操作系统中能(同时)运行多个任务(程序)  例如:Android你没启动一个”软件“开启一个进程
    多线程:在同一个应用程序中。。。。

    -------------------------------------------------------------

    线程进入就绪状态,还不能直接运行, 还要抢CPU, 谁抢到who运行
    程序要运行必须经过CPU--一个CPU同时只能执行一条指令



    上面单线程程序
    下面多线程程序

    ------------------------------------------------------------------------

    1. //如果抽象类的类体里的方法全部都是抽象方法,可以把这个类定义为接口  
    2. //换言之,类体里全部都是抽象方法,可以把这个类定义为接口.  
    3. interface Runer//接口的定义,接口里只包含常量和抽象方法.  
    4. {  
    5.     String texing="动时要振动";//接口里的常量默认是用public static final标志的  
    6.     void run();//默认的访问权限是public.  
    7.     String jump();  
    8. }  
    9.   
    10. interface Animals extends Runer//一个新的接口可以继承另一个接口  
    11. {  
    12.     void breathe();//在继承的基础上,有新的矿展.动物不仅能动,还能呼吸.  
    13. }  
    14. //实现接口抽象方法的方式 注意联想实现抽象类里的抽象方法的方式.  
    15. abstract class Fish  implements Animals//实现接口抽象方法的定义  
    16. {//如果省掉abstract, Fish类类体必须覆盖Animals里的所有抽象方法,否则报错.  
    17.     public void run()//public不能省,因为上面都是public型,子类访问父类,访问权限不能比父类低  
    18.     {  
    19.     System.out.println("Fish is swiming");  
    20.     }  
    21.     public String jump()  
    22.     {  
    23.         System.out.println("Fish靠尾巴跳动");  
    24.         return "wooo";  
    25.     }  
    26.     public void breathe()  
    27.     {  
    28.     System.out.println("Fish呼出的是汽泡");  
    29.     }  
    30. }  
    31. //比较:实现抽象类的抽象方法与实现接口的抽象方法所采取的方式.  
    32. //实现抽象类的抽象方法,是通过abstract class 子类名 extends 父类名     -----格式  
    33. //实现接口的抽象方法,是通过abstract class 类名a  implements 类名b       ------格式  
    34. //两者相同点:都要声明抽象类abstract class 类名,不同点,前者用关键字extends  
    35. //后者用implements  


    简洁代码:

    [java]  view plain copy print ?
    1. interface Runer  
    2. {  
    3.     String texing="动时要振动";  
    4.     void run();  
    5.     String jump();  
    6. }  
    7.   
    8. interface Flyer  
    9. {     
    10.     int ID=20;  
    11.     void fly();  
    12. }  
    13.   
    14. interface Animals extends Runer  
    15. {  
    16.     void breathe();  
    17. }  
    18.   
    19. abstract class Bird implements Runer,Flyer//实现多个接口  
    20. {  
    21.     public void run() {}  
    22. }  
    23. abstract class Fish  implements Animals//实现接口  
    24. {  
    25.     public void run()  
    26.     {  
    27.     System.out.println("Fish is swiming");  
    28.     }  
    29.     public String jump()  
    30.     {  
    31.         System.out.println("Fish靠尾巴跳动");  
    32.         return "wooo";  
    33.     }  
    34.     public void breathe()  
    35.     {  
    36.     System.out.println("Fish呼出的是汽泡");  
    37.     }  
    38. }  
    39. //class person {}  
    40. abstract class student extends person implements Runer,Flyer//继承一个类的同时,实现多个接口.  
    41. {  
    42.     public void run() {}  
    43.     public String jump(){return "ee";}  
    44. }  

    --------------------------------------------------------------------------------------------------------------

    1.包的概念

    包(package)是Java提供的一种区别类的名字空间的机制,是类的组织方式,是一组相关类和接口的集合,它提供了访问权限和命名的管理机制。

    Java中提供的包主要有以下3种用途:

      1) 将功能相近的类放在同一个包中,可以方便查找与使用。

      2) 由于在不同包中可以存在同名类,所以使用包在一定程度上可以避免命名冲突。

      3) 在Java中,某次访问权限是以包为单位的。

    1.1创建包

    创建包可以通过在类或接口的源文件中使用 package语句实现,package语句的语法格式如下:

    package 包名;

    包名:必选,用于指定包的名称,包的名称为合法的 Java标识符。当包中还有包时,可以使用“包1.包2.…….包n”进行指定,其中,包1为最外层的包,而包n则为最内层的包。

    package 语句通常位于类或接口源文件的第一行。例如,定义一个类Circ,将其放入com.wgh包中的代码如下:

    package com.wgh;

    public class Circ {

    final float PI=3.14159f;       //定义一个用于表示圆周率的常量PI

    // 定义一个绘图的方法

    public void draw(){

    System.out.println("画一个圆形!");

    }

    }

    说明:

    在Java中提供的包,相当于系统中的文件夹。例如,上面代码中的Circ类如果保存到C盘根目录下,那么它的实际路径应该为C:\com \wgh\Circ.java。

    使用包中的类

    类可以访问其所在包中的所有类,还可以使用其他包中的所有public类。访问其他包中的public类可以有以下两种方法。

    1) 使用长名引用包中的类

    使用长名引用包中的类比较简单,只需要在每个类名前面加上完整的包名即可。例如,创建Circ类(保存在com.wgh包中)的对象并实例化该对象的代码如下:

    com.wgh.Circ circ=new com.wgh.Circ();

    2) 使用import语句引入包中的类

    由于采用使用长名引用包中的类的方法比较繁琐,所以Java提供了import语句来引入包中的类。import语句的基本语法格式如下:

    import 包名1[.包名2.……].类名|*;

    当存在多个包名时,各个包名之间使用“.”分隔,同时包名与类名之间也使用“.”分隔。

    *:表示包中所有的类。

    例如,引入com.wgh包中的Circ类的代码如下:

    import com.wgh.Circ;

    如果 com.wgh包中包含多个类,也可以使用以下语句引入该包下的全部类。

    import com.wgh.*;

    JAVA的extends用法

       理解继承是理解面向对象程序设计的关键。在Java中,通过关键字extends继承一个已有的类,被继承的类称为父类(超类,基类),新的类称为子类(派生类)。在Java中不允许多继承。
    (1)继承

    [java]  view plain copy 在CODE上查看代码片 派生到我的代码片
    1. class Animal{  
    2.     void eat(){  
    3.         System.out.println("Animal eat");  
    4.     }  
    5.     void sleep(){  
    6.         System.out.println("Animal sleep");  
    7.     }  
    8.     void breathe(){  
    9.         System.out.println("Animal breathe");  
    10.     }  
    11. }  
    12.   
    13. class Fish extends Animal{  
    14. }  
    15.   
    16. public class TestNew {  
    17.     public static void main(String[] args) {  
    18.         // TODO Auto-generated method stub  
    19.         Animal an = new Animal();  
    20.         Fish fn = new Fish();  
    21.           
    22.         an.breathe();  
    23.         fn.breathe();  
    24.     }  
    25. }  

    在eclipse执行得:
    Animal breathe! 
    Animal breathe! 
    .java文件中的每个类都会在文件夹bin下生成一个对应的.class文件。执行结果说明派生类继承了父类的所有方法。

    (2)覆盖

    [java]  view plain copy 在CODE上查看代码片 派生到我的代码片
    1. class Animal{  
    2.     void eat(){  
    3.         System.out.println("Animal eat");  
    4.     }  
    5.     void sleep(){  
    6.         System.out.println("Animal sleep");  
    7.     }  
    8.     void breathe(){  
    9.         System.out.println("Animal breathe");  
    10.     }  
    11. }  
    12.   
    13. class Fish extends Animal{  
    14.     void breathe(){  
    15.         System.out.println("Fish breathe");  
    16.     }  
    17. }  
    18.   
    19. public class TestNew {  
    20.     public static void main(String[] args) {  
    21.         // TODO Auto-generated method stub  
    22.         Animal an = new Animal();  
    23.         Fish fn = new Fish();  
    24.           
    25.         an.breathe();  
    26.         fn.breathe();  
    27.     }  
    28. }  

    执行结果:

    Animal breathe
    Fish breathe

    在子类中定义一个与父类同名,返回类型,参数类型均相同的一个方法,称为方法的覆盖。方法的覆盖发生在子类与父类之间。另外,可用super提供对父类的访问。

     

    java中的继承


    java中的继承(子类调用父类构造方法还不懂) 

    declarations  n. 声明
    extends  v. 继承


    继承中注意的问题:
    1  重写(也叫覆盖,也叫重构):重写方法必须和被重写方法具有相同的方法名称、参数列表和返回值类型;
                重写方法不能使用比被重写方法更严格的访问权限。
    重写是类与类之间的关系,两者必须是继承关系。重载是方法与方法之间的关系。

    2  关键字super:
        在Java类中使用super来引用父类的成分
        super可用于访问父类中定义的属性
        super可用于调用父类中定义的成员方法
        super可用于在子类构造方法中调用父类的构造方法
        super的追溯不仅于直接父类,就是father的father。。。。。。
    Supper关键字有两个特殊的用途:
        在子类构造函数中调用父类的构造函数
        在子类中调用父类的方法。

    3  多态:多态就是重写和重载!而上塑造型或虚方法的调用更好的体现了多态。
                 上溯造型(也叫虚方法)中,方法是调用子类自己的,属性是调用父类的。(一个引用类型变量如果声明为父类的类型,
                 但实际引用的是子类对象,那么该变量就不能再访问子类中添加的属性和方法)
    public class Father {    
        public String name = "王惠";
        public void bidBoy(){
            System.out.println("今天我要是不打你,我就不是你娘!!!");    
        }
    }

    public class Son1 extends Father{
        public String name1 = "王鹏的姐姐";
        public String name = "张三三";
        public void bidBoy(){   //重写
            System.out.println("我做错了什么?为什么你要打我!!!");
            System.out.println(super.name);
            System.out.println(name);//如果子类没有name,那么这个name就输出父类的。
        }
    }

    public class Test{
        public static void main(String args[]){
            Father f = new Son1(); //上溯造型,虚方法调用
            f.bidBoy();//这里调用的是子类中重写父类的方法!上溯造型中,方法是调用子类自己的,属性是调用父类的。
            System.out.println(f.name);
        }
    }
    输出结果:
        我做错了什么?为什么你要打我!!!
        王惠
        张三三
        王惠

    同类收集( homogenous collections)

        MyDate[] m = new MyDate[2];
        m[0] = new MyDate(22, 12, 1964);
        m[1] = new MyDate(22, 7, 1964);

      异类收集(heterogeneous collections)

        Person [] p= new Person[3];
        p[0] = new Student();//跟person有继承关系
        p[1] = new Person();
        p[2] = new Graduate();//跟person有继承关系

    方法声明的参数类型为父类类型,可以使用子类的对象作为实参调用该方法
    public class Test{ 
        public void method(Person e) {
                   //……
                   e.getInfo();
        }
        public static  void main(String args[]){
                   Test t = new Test();
                    Student m = new Student();
                    t.method(m);
        }
    }

    4 instanceof 操作符:instanceof操作符的作用是判断一个变量是否是右操作数指出的类的一个对象,
        由于java语言的多态性使得可以用一个子类的实例赋值给一个父类的变量,而在一些情况
        下需要判断变量到底是一个什么类型的对象,这时就可以使用instanceof了。当左操作数是
        右操作数指出的类的实例或者是子类的实例时都返回真,如果是将一个子类的实例赋值给
        一个父类的变量,用instanceof判断该变量是否是子类的一个实例时也将返回真。

    5 对象造型 :
        对Java对象的强制类型转换称为造型
        在造型前可以使用instanceof操作符测试一个对象的类型
        从子类到父类的类型转换可以自动进行
        从父类到子类的类型转换必须通过造型(强制类型转换)实现
        无继承关系的引用类型间的转换是非法的

    public class Test{        
           public void method(Person e) {
              System.out.println(e.getschool());   //非法,因为从子类到父类的类型转换可以自动进行,故这里已经是父类了。父类的对象只能调用父类中有的方法。
              if(e intstanceof Student){
                      Student me = (Student)e;
                      System.out.println(me.getschool());
              }        
           }
            public static  void main(Stirng args[]){
                   Test t = new Test();
                    Student m = new Student();
                    t.method(m);
            }
    }

    综合例子:
    public class Animal {
        public String name;
        public void run()
        {
            System.out.println("交通基本靠跑");
        }
        public void say()
        {
            System.out.println("通讯基本靠叫");
      }
    }

    public class Cat extends Animal{
        /*
         * 如果存在继承关系的话,子类会默认的调用父类的默认构造器,而如果重载父类的构造器,
         * 子类需要调用重载之后的构造器,且父类的构造器必须在子类的最开始最前端进行调用。
         * 
         */
        public Cat()
        {
            super();
        }    
        public void worke()
        {
            System.out.println("猫挠沙发...咔咔...");
        }
        public void say()
        {
            System.out.println("喵喵...");
        }
    }

    public class Dog extends Animal{
        public void worke()
        {
            System.out.println("狗看门儿!!");
        }
        public void say()
        {
            System.out.println("汪汪汪...");
        }
    }

    public class AnimalFactory {
        public static void method(Animal[] animal)
        {
            //循环,遍历出Animal数组当中所有的对象并调用Cat/Dog当中的worke/say方法及Animal当中的run/say方法。
            for(Animal a:animal)
            {
                if(a instanceof Dog)
                {
                    Dog d = (Dog)a;
                    d.worke();
                    d.say();
                    continue;
                }
                if(a instanceof Cat)
                {
                    Cat c = (Cat)a;
                    c.worke();
                    c.say();
                    continue;
                }
                if(a instanceof Animal)
                {
                    continue;//这个continue可以省掉
                }
            }
        }
    }

    public class TestAnimal {
        public static void main(String[] args){    
            Animal[] a = new Animal[3];
            //异类收集
            a[0] = new Dog();
            a[1] = new Cat();
            a[2] = new Animal();
            ((Cat)a[1]).worke();//强制类型转换,因为worke()这个不是子类重写父类的方法,所以必须强制类型转换~
            a[1].say();//这句不需要强制类型转换,因为say()是子类重写父类的方法。
            AnimalFactory.method(a);//method方法是静态的,可以直接调用,当然写上面那条语句也没有错。    
        }
    }
    输出结果:    
        猫挠沙发...咔咔...
        喵喵...
        狗看门儿!!
        汪汪汪...
        猫挠沙发...咔咔...
        喵喵...

    6 方法重载:在同一个类中可以定义多个同名方法。
          重载方法的参数列表必须不同,也就是参数个数或参数类型不同!
          重载方法的返回值类型可以相同,也可以不同
    构造方法重载:
        构造方法重载,参数列表必须不同,也就是参数个数或参数类型不同!
        可以在构造方法的第一行使用this关键字调用本类的其它(重载的)构造方法
    import java.util.Date;
    public class Person {
                private String name;
                private int age;
                private Date birthDate;//Date类型引入util包
                public Person(String name, int age, Date d) {
         this.name = name;
         this.age = age;
         this.birthDate = d;
              }
              public Person(String name, int age) {
         this(name, age, null);
              }
              public Person(String name, Date d) {
         this(name, 30, d);
              }
              public Person(String name) {
         this(name, 30);
              }
    }

    构造方法不能继承:子类继承父类所有的成员变量和成员方法,但不继承父类的构造方法
    调用父类构造方法:子类的构造方法必须调用父类的构造方法!
        如果子类的构造方法中没有显示地调用父类构造方法,也没有使用this关键字调用重载的其它构造方法,则系统默认调用父类无参数的构造方法
        如果子类构造方法中既未显式调用父类构造方法,而父类中又没有无参的构造方法,则编译出错
        在子类的构造方法中可使用语句super(argument_list) 调用父类的构造方法


    展开全文
  • 小白,你要的Java抽象类,操碎了心!

    千次阅读 多人点赞 2020-05-06 07:39:39
    自从给小白写了两篇科普性质的文章后,我就有点一发不可收拾,觉得很有必要继续写下去。因为有读者留言“鼓励”我说,“二哥,你真的是为小白操碎了心啊!...1)定义抽象类的时候需要用到关键字 abstract,放在...

    自从给小白写了两篇科普性质的文章后,我就有点一发不可收拾,觉得很有必要继续写下去。因为有读者留言“鼓励”我说,“二哥,你真的是为小白操碎了心啊!”我容易吗?我。

    当我们要完成的任务是确定的,但具体的方式需要随后开个会投票的话,Java 的抽象类就派上用场了。这句话怎么理解呢?搬个小板凳坐好,听我来给你讲讲。

    01、抽象类的 5 个关键点

    1)定义抽象类的时候需要用到关键字 abstract,放在 class 关键字前。

    public abstract class AbstractPlayer {
    }
    

    关于抽象类的命名,阿里出品的 Java 开发手册上有强调,“抽象类命名要使用 Abstract 或 Base 开头”,记住了哦。

    2)抽象类不能被实例化,但可以有子类。

    尝试通过 new 关键字实例化的话,编译器会报错,提示“类是抽象的,不能实例化”。

    通过 extends 关键字可以继承抽象类,继承后,BasketballPlayer 类就是 AbstractPlayer 的子类。

    public class BasketballPlayer extends AbstractPlayer {
    }
    

    3)如果一个类定义了一个或多个抽象方法,那么这个类必须是抽象类。

    当在一个普通类(没有使用 abstract 关键字修饰)中定义了抽象方法,编译器就会有两处错误提示。

    第一处在类级别上,提醒你“这个类必须通过 abstract 关键字定义”,or 的那个信息没必要,见下图。

    第二处在方法级别上,提醒你“抽象方法所在的类不是抽象的”,见下图。

    4)抽象类可以同时声明抽象方法和具体方法,也可以什么方法都没有,但没必要。就像下面这样:

    public abstract class AbstractPlayer {
        abstract void play();
        
        public void sleep() {
            System.out.println("运动员也要休息而不是挑战极限");
        }
    }
    

    5)抽象类派生的子类必须实现父类中定义的抽象方法。比如说,抽象类中定义了 play() 方法,子类中就必须实现。

    public class BasketballPlayer extends AbstractPlayer {
        @Override
        void play() {
            System.out.println("我是张伯伦,篮球场上得过 100 分");
        }
    }
    

    如果没有实现的话,编译器会提醒你“子类必须实现抽象方法”,见下图。

    02、什么时候用抽象类

    与抽象类息息相关的还有一个概念,就是接口,我们留到下一篇文章中详细说,因为要说的知识点还是蛮多的。你现在只需要有这样一个概念就好,接口是对行为的抽象,抽象类是对整个类(包含成员变量和行为)进行抽象。

    (是不是有点明白又有点不明白,别着急,翘首以盼地等下一篇文章出炉吧)

    除了接口之外,还有一个概念就是具体的类,就是不通过 abstract 修饰的普通类,见下面这段代码中的定义。

    public class BasketballPlayer {
       public void play() {
            System.out.println("我是詹姆斯,现役第一人");
        }
    }
    

    有接口,有具体类,那什么时候该使用抽象类呢?

    1)我们希望一些通用的功能被多个子类复用。比如说,AbstractPlayer 抽象类中有一个普通的方法 sleep(),表明所有运动员都需要休息,那么这个方法就可以被子类复用。

    public abstract class AbstractPlayer {
        public void sleep() {
            System.out.println("运动员也要休息而不是挑战极限");
        }
    }
    

    虽然 AbstractPlayer 类可以不是抽象类——把 abstract 修饰符去掉也能满足这种场景。但 AbstractPlayer 类可能还会有一个或者多个抽象方法。

    BasketballPlayer 继承了 AbstractPlayer 类,也就拥有了 sleep() 方法。

    public class BasketballPlayer extends AbstractPlayer {
    }
    

    BasketballPlayer 对象可以直接调用 sleep() 方法:

    BasketballPlayer basketballPlayer = new BasketballPlayer();
    basketballPlayer.sleep();
    

    FootballPlayer 继承了 AbstractPlayer 类,也就拥有了 sleep() 方法。

    public class FootballPlayer extends AbstractPlayer {
    }
    

    FootballPlayer 对象也可以直接调用 sleep() 方法:

    FootballPlayer footballPlayer = new FootballPlayer();
    footballPlayer.sleep();
    

    2)我们需要在抽象类中定义好 API,然后在子类中扩展实现。比如说,AbstractPlayer 抽象类中有一个抽象方法 play(),定义所有运动员都可以从事某项运动,但需要对应子类去扩展实现。

    public abstract class AbstractPlayer {
        abstract void play();
    }
    

    BasketballPlayer 继承了 AbstractPlayer 类,扩展实现了自己的 play() 方法。

    public class BasketballPlayer extends AbstractPlayer {
        @Override
        void play() {
            System.out.println("我是张伯伦,我篮球场上得过 100 分,");
        }
    }
    

    FootballPlayer 继承了 AbstractPlayer 类,扩展实现了自己的 play() 方法。

    public class FootballPlayer extends AbstractPlayer {
        @Override
        void play() {
            System.out.println("我是C罗,我能接住任意高度的头球");
        }
    }
    

    3)如果父类与子类之间的关系符合 is-a 的层次关系,就可以使用抽象类,比如说篮球运动员是运动员,足球运动员是运动员。

    03、具体示例

    为了进一步展示抽象类的特性,我们再来看一个具体的示例。假设现在有一个文件,里面的内容非常简单——“Hello World”,现在需要有一个读取器将内容读取出来,最好能按照大写的方式,或者小写的方式。

    这时候,最好定义一个抽象类,比如说 BaseFileReader:

    public abstract class BaseFileReader {
        protected Path filePath;
    
        protected BaseFileReader(Path filePath) {
            this.filePath = filePath;
        }
    
        public List<String> readFile() throws IOException {
            return Files.lines(filePath)
                    .map(this::mapFileLine).collect(Collectors.toList());
        }
    
        protected abstract String mapFileLine(String line);
    }
    

    filePath 为文件路径,使用 protected 修饰,表明该成员变量可以在需要时被子类访问。

    readFile() 方法用来读取文件,方法体里面调用了抽象方法 mapFileLine()——需要子类扩展实现大小写的方式。

    你看,BaseFileReader 设计的就非常合理,并且易于扩展,子类只需要专注于具体的大小写实现方式就可以了。

    小写的方式:

    public class LowercaseFileReader extends BaseFileReader {
        protected LowercaseFileReader(Path filePath) {
            super(filePath);
        }
    
        @Override
        protected String mapFileLine(String line) {
            return line.toLowerCase();
        }
    }
    

    大写的方式:

    public class UppercaseFileReader extends BaseFileReader {
        protected UppercaseFileReader(Path filePath) {
            super(filePath);
        }
    
        @Override
        protected String mapFileLine(String line) {
            return line.toUpperCase();
        }
    }
    

    你看,从文件里面一行一行读取内容的代码被子类复用了——抽象类 BaseFileReader 类中定义的普通方法 readFile()。与此同时,子类只需要专注于自己该做的工作,LowercaseFileReader 以小写的方式读取文件内容,UppercaseFileReader 以大写的方式读取文件内容。

    接下来,我们来新建一个测试类 FileReaderTest:

    public class FileReaderTest {
        public static void main(String[] args) throws URISyntaxException, IOException {
            URL location = FileReaderTest.class.getClassLoader().getResource("helloworld.txt");
            Path path = Paths.get(location.toURI());
            BaseFileReader lowercaseFileReader = new LowercaseFileReader(path);
            BaseFileReader uppercaseFileReader = new UppercaseFileReader(path);
            System.out.println(lowercaseFileReader.readFile());
            System.out.println(uppercaseFileReader.readFile());
        }
    }
    

    项目的 resource 目录下有一个文本文件,名字叫 helloworld.txt。

    可以通过 ClassLoader.getResource() 的方式获取到该文件的 URI 路径,然后就可以使用 LowercaseFileReader 和 UppercaseFileReader 两种方式读取到文本内容了。

    输出结果如下所示:

    [hello world]
    [HELLO WORLD]
    


    好了,我亲爱的读者朋友,以上就是本文的全部内容了。是不是感觉认知边界又拓宽了?

    我是沉默王二,一枚有趣的程序员。如果觉得文章对你有点帮助,请微信搜索「 沉默王二 」第一时间阅读,回复【666】更有我为你精心准备的 500G 高清教学视频(已分门别类)。

    本文 GitHub 已经收录,有大厂面试完整考点,欢迎 Star。

    原创不易,莫要白票,请你为本文点个赞吧,这将是我写作更多优质文章的最强动力。

    展开全文
  • 抽象类和接口

    千次阅读 2019-12-07 09:56:05
    抽象类和接口 回顾 1 Object 类 ,是所有的父类,默认继承Object equals()方法:判断两个对象是否相等 return this==obj; == : 基本类型比较的数据,引用类型比较的地址。 equals() 默认 和== 一样, ...

    抽象类和接口

    回顾

    1 Object 类 ,是所有的父类,默认继承Object
    
    	equals()方法:判断两个对象是否相等     return this==obj;
    
    		==  : 基本类型比较的数据,引用类型比较的地址。
    
    		equals()  默认 和== 一样,
    		
    		String中 equals重写了Object中的equals方法
    
    	hashCode()方法:返回对象的地址
    
    	getClass()方法:返回类对象
    
    	toString()方法:返回对象的字符串形式, com.qf.day10.Person@123142;  重写
    
    2 多态:同一个引用类型,使用不同的实例,执行不同的操作, 父类引用,子类对象
    
    	实现多态的要素或条件:
    
    	1 子类继承父类,子类必须重写父类的方法
    
    	2 使用父类变量,子类对象 
    
    	多态表现形式:
    
    	1 使用父类作为方法的参数
    
    	2 使用父类作为方法的返回值
    
            向上转型和向下转型
    
    	向上转型:子类转成父类
    
    	向下转型:父类转成子类
    
    	instanceof: 判断变量是否是某种类型。
    
    	if(pet instanceof Dog){		
    
    		Dog dog=(Dog)pet;
    
    	}
    
    3 final  终止的
    
    	3.1 final 修饰变量   常量:只能赋值一次。
    
    		修饰成员变量
    
    		修饰局部变量
    
    	3.2 final 修饰方法  终止方法不能被重写,能被继承
    
    	3.3 final 修饰类,终止类,不能被继承。
    

    今天任务

    1. 抽象类
    2. 抽象方法
    3. 接口
    

    教学目标

    1. 掌握抽象类
    2. 掌握抽象方法
    3. 掌握接口
    4. 掌握抽象类和接口的区别
    

    第一节: 抽象类

    1.1 为什么使用抽象类
    • 有些类创建对象没有意义。需要把这个定义为抽象类
      • 1 Animal animal=new Animal();
      • 2 Pet pet=new Pet()
    • 使用abstract修饰类变成抽象类:不能实例化,只能被继承
    • 抽象类的构造方法不能直接使用,只能被子类调用。
    1.2 abstract 关键字

    关键字:abstract:抽象

    可以修饰类:叫做抽象类

    可以修饰方法:叫做抽象方法,没有方法体,需要使用分号表示声明结束,抽象方法所在的类必须是抽象类

    子类必须重写父类的抽象方法,除非子类也是抽象类

    1.3 抽象方法

    使用abstract关键字修饰,只表示声明了一个方法,但是没有任何的实现

    特点:
    ​ 1)没有方法体,需要使用分号表示方法声明结束
    ​ 2)如果一个类中有一个方法是抽象的,那么这个类必须是抽象的
    ​ 3)抽象方法必须被子类重写,除非子类也是抽象类

    1.4 抽象类:

    使用abstract关键字修饰
    特点:
    ​ 1)抽象类中可以包含抽象方法,也可以包含普通方法。
    ​ 2)抽象类中有构造方法,但是不能创建对象,构造方法目的在子类中会被调用。
    ​ 3)抽象类的存在就是为了被继承,子类必须重写父类的抽象方法,除非子类也是抽象类。

    1.5 抽象类和普通类的区别:

    ​ 1)抽象类需要abstract,而普通类不需要
    ​ 2)构造方法:都有,但是抽象类不能实例化对象,普通类可以
    ​ 3)成员方法:抽象类中可以存在抽象的成员方法也可以存在非抽象成员方法,而普通类中只能存在非抽象成员方法

    思考:final和abstract是否可以连用?

    1)两个关键字修饰方法时,final修饰的方法特点:可以被继承不能被重写;abstract修饰的方法特点:必须被重写;所以这两个关键字不能同时修饰同一个方法

    2)两个关键字修饰类时:final修饰的类特点:不能被继承;abstract修饰的类特点:必须被继承;所以这两个关键字不能同时修饰同一个类

    综上所述:final和abstract不可以连用

    final的类中能否有abstract方法?不能
    abstract类中能否有final方法?可以

    上机练习1:

    编写交通工具类,具有前进run()功能,子类有自行车、小轿车、地铁,重写父类方法,主人有属性name,age属性,方法回家goHome(交通工具),需要使用交通工具,使用抽象类优化程序
    TrafficTool
    Bicycle
    Car
    Subway
    Master
    
    
    package com.qf.day12;
    /**
     * 编写交通工具类,具有前进run()功能,子类有自行车、小轿车、地铁,重写父类方法,主人有属性name,age属性,方法回家goHome(交通工具),需要使用交通工具,使用抽象类优化程序
    TrafficTool
    Bicycle
    Car
    Subway
    Master
     * @author wgy
     *
     */
    public abstract class TracficTool {
    	//品牌
    	private String brand;
    
    	public String getBrand() {
    		return brand;
    	}
    
    	public void setBrand(String brand) {
    		this.brand = brand;
    	}
    	public TracficTool() {
    		// TODO Auto-generated constructor stub
    	}
    
    	public TracficTool(String brand) {
    		super();
    		this.brand = brand;
    	}
    	
    	/**
    	 * 前进方法
    	 */
    	public abstract void run();
    	
    }
    
    
    package com.qf.day12;
    
    public class Bicycle extends TracficTool {
    	
    	public Bicycle() {
    		// TODO Auto-generated constructor stub
    	}
    	
    	
    	
    	public Bicycle(String brand) {
    		super(brand);
    	}
    
    
    
    	@Override
    	public void run() {
    		System.out.println(getBrand()+"的自行车,在行驶...............");
    	}
    }
    
    package com.qf.day12;
    
    public class Car extends TracficTool{
    
    	public Car() {
    		// TODO Auto-generated constructor stub
    	}
    	
    	
    	public Car(String brand) {
    		super(brand);
    		// TODO Auto-generated constructor stub
    	}
    
    
    	@Override
    	public void run() {
    		System.out.println(getBrand()+"轿车正在飞速的前进............");
    	}
    }
    
    package com.qf.day12;
    
    public class Subway extends TracficTool {
    	public Subway() {
    		// TODO Auto-generated constructor stub
    	}
    	
    	
    	public Subway(String brand) {
    		super(brand);
    		// TODO Auto-generated constructor stub
    	}
    
    
    	@Override
    	public void run() {
    		System.out.println(getBrand()+"地铁,在高速前进..............");
    	}
    }
    
    package com.qf.day12;
    /**
     * 主人
     * @author wgy
     *
     */
    public class Master {
    	private String name;
    	private int age;
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	
    	public Master() {
    		// TODO Auto-generated constructor stub
    	}
    	public Master(String name, int age) {
    		super();
    		this.name = name;
    		this.age = age;
    	}
    	
    	//回家
    	
    	public void goHome(TracficTool tool) {
    		System.out.println(getName()+"下班了,要回家...");
    		tool.run();
    		System.out.println(getName()+"到家了...");
    	}
    	
    	
    	
    }
    
    
    package com.qf.day12;
    
    public class Test {
    	public static void main(String[] args) {
    		Master zhengshuai=new Master("郑帅", 29);
    		Bicycle fenghuang=new Bicycle("凤凰牌");
    		Car baoshijie=new Car("保时捷");
    		Subway shuaishuai=new Subway("北京地铁");
    		
    		zhengshuai.goHome(fenghuang);
    		zhengshuai.goHome(baoshijie);
    		zhengshuai.goHome(shuaishuai);
    		
    	}
    }
    
    
    1.6 static,final,abstract总结
    修饰符修饰对象规则
    static属性表示类公共的属性,使用类来调用,推荐使用类调用(类名.属性名)
    方法表示类公共的方法,在静态方法中只能直接调用静态变量或静态方法,不能使用this,super,如果要想调用非静态方法和属性,需要创建对象。
    代码块静态代码块,程序一加载静态代码块就运行,而且只运行一次
    final属性、局部变量常量,final int i=12;或者final int i;i=12;只能赋值一次。
    方法该方法不能被子类重写,可以被继承。
    该类不能被继承。
    abstract方法抽象方法,该方法只有方法声明,没有方法体
    构造方法和static方法、final方法不能是抽象的
    有该方法的类称为抽象类,类名前必须加abstract
    抽象类不能被实例化
    抽象类可以指向子类对象的引用
    抽象类可以有普通方法,可以被子类继承
    父类的抽象方法必须在子类中实现,除非子类也是抽象类

    第二节: 接口

    生活中的接口:USB,插座…

    USB:物理:必须满足USB接口的宽度和厚度
    ​ 内部:需要遵守磁片的个数

    插座:首先需要满足插头的个数
    ​ 满足电压和电流一些规则

    2.1 接口的概念

    从语法上讲:

    接口是一种特殊的抽象类,这种抽象类中只包含常量和方法的定义,而没有方法的实现。

    从功能上讲:接口表示一种约定或能力

    2.2 使用接口的好处
    • 扩展类的功能,保持对外接口一致
    • 接口实现了多重继承,完成类和任何实现接口子类的通信和交互
    • 降低代码之间的耦合性
    2.3 接口的特点:

    1)接口不能创建对象,而且接口中没有构造方法;
    2)接口中的方法一般都是共有抽象方法:public abstract
    3)接口中所有的属性都是共有静态常量属性:pulbic static final

    在一个接口中声明方法时,若没有声明访问权限,默认也是public,若没其他修饰默认也是abstract;声明属性时,若没有声明访问权限和静态常量,默认也是public static final

    public abstract void fun();
    接口中可以使用一下格式声明方法:
    void fun();
    public static final int a = 9;
    int a = 9;
    
    
    
    
    2.4 接口的声明语法

    关键字interface:表示一个接口,接口interface和类class是平级关系

    接口名命名:

    ​ 如果接口表示一种能力,命名采用:名字+后缀able ,比如 Serializable Comparable

    ​ 如果接口表示一种约定或规范 ,按照命名规范正常命名 USB , Comparator,CharSequence

    语法:
    public interface 接口名{
    	//接口中的成员:抽象方法和静态常量
    }
    
    2.5 接口的实现类

    接口与类的关系:implements

    语法:

    pulbic interface I{
    	public abstract void fun();
    }
    
    public class Impl implements I {
    	public void fun(){}
    }
    

    思考:一个类实现某个接口之后,是否可以存在父类?
    ​ 可以,实现接口和继承类不冲突

    注意:若一个类有父类同时也实现接口,声明类时,必须先继承再实现接口

    语法:

    public class Dog extends Animal implements I{
      	public void fun(){}
    }
    
    2.6 接口的分类:

    1)普通接口:在接口中可以声明抽象方法,和静态常量属性
    2)常量群接口:在接口中只声明一组静态常量属性
    3)标志性接口:在接口中没有抽象方法,也没有静态常量,作用为了标记某个类具有某个功能

    2.7 接口和接口的关系:

    继承关系:使用关键字extends实现接口与接口的继承关系

    接口继承的特点:
    1)接口中没有私有成员,所以父类接口中的所有成员都会被子接口继承
    2)父子关系中都是接口,所以在子接口中不需要实现任何的抽象方法
    3)接口可以多继承

    思考:
    现有类A和类B,两个类中都有fun()方法,假如类C继承类A和类B,当使用类C的对象调用fun方法时,如何执行?此时不知道执行那个fun方法,所以类不可以多继承。

    现有接口A,B,两个接口中都有fun方法,接口C继承A,B,由于接口中的没有方法体,所在只要在接口C中存在了fun方法即可

    所以接口支持多继承

    2.7 接口中特殊的方法:

    1)jdk1.8之后接口中使用static关键字修饰的方法有方法体
    ​ 静态方法需要有方法体
    2)jdk1.8之后接口中使用default关键字修饰的方法有方法体

    2.8 接口的使用:

    1.USB接口

    public interface USBInterface {
    	public void server();
    }
    
    public class Fan implements USBInterface {
    	public void server() {
    		// TODO Auto-generated method stub
    		System.out.println("风扇和电脑连接成功,开始工作");
    	}
    }
    
    public class Mouse implements USBInterface{
    	public void server() {
    		// TODO Auto-generated method stub
    		System.out.println("鼠标和电脑连接成功,开始工作");
    	}
    }
    
    public class Computer {
    	//面向接口编程,而不面向具体的实现
    	public USBInterface  usb1;
    	public USBInterface  usb2;
    	public USBInterface  usb3;
    	
    	public void Run(){
    		System.out.println("电脑启动成功");
    		if(usb1!=null) {
    			usb1.service();
    		}
    		if(usb2!=null) {
    			usb2.service();
    		}
    		if(usb3!=null) {
    			usb3.service();
    		}
    	}
    }
    

    2.在一个平台或系统中,如果多个类都需要使用到某些方法(功能),可以将这些方法定义到一个接口中,所有需要这些方法的类,可以实现这个接口,有效地实现解耦。

    案例:现有交通工具类Transport类
    ​ Transport有三个子类,飞机Plane,车Car,船Ship

    ​ Plane有,客机,货机,战斗机
    ​ Car有客车,货车,坦克
    ​ Ship船有客船,货船,航母

    战斗机,坦克,航母都有开火攻击的功能,通过分析,此功能不能来自于父类,所以可以将开火攻击的功能设置在一个接口中

    //交通工具类
    public class Transport {
    	//成员方法
    	public void yun(String goods) {
    		System.out.println("运输"+goods);
    	}
    }
    //飞机类
    public class Plane extends Transport {}
    //船类
    public class Ship extends Transport {}
    //车类
    public class Car extends Transport {}
    //开火攻击接口
    public interface Fire {
    	public abstract void fire();//开火攻击方法
    }
    //航母类:继承Ship,实现Fire
    public class Carrer extends Ship implements Fire {
    	@Override
    	public void fire() {
    		// TODO Auto-generated method stub
    		System.out.println("xiu~~~");
    	}
    }
    //战斗机:继承Plane,实现Fire
    public class FightingPlane extends Plane implements Fire {
    	@Override
    	public void fire() {
    		// TODO Auto-generated method stub
    		System.out.println("piupiupiu~~");
    	}
    }
    //坦克类:继承Car,实现Fire
    public class Tank extends Car implements Fire {
    	@Override
    	public void fire() {
    		// TODO Auto-generated method stub
    		System.out.println("轰轰轰~~~");
    	}
    }
    //测试
    public class TestTransport {	
    	public static void main(String[] args) {
    		FightingPlane fp = new FightingPlane();
    		fp.yun("炸药");
    		fp.fire();//战斗机对象的开火攻击的功能来源于Fire接口
    		//可以使用接口的引用指向实现类的实例
    		Fire f = new Tank();	
    	}
    }
    
    2.9 抽象类和接口区别

    语法:

    1>抽象类使用abstract,接口使用interface

    2>抽象类中可以包含抽象方法,也可以包含非抽象方法,接口中只能包含抽象方法和静态常量,jdk1.8之后接口可以包含静态方法和默认方法。

    3>抽象类和接口都不能实例化。

    4>抽象类可以包含构造方法,接口中没有构造方法。

    功能:

    1>抽象类一般用来表示同类事物,接口可以表示不是同类事物。

    2>抽象类可以实现代码的重用,也可以约束子类的功能。接口就是约束实现类的功能,降低代码之间的耦合性。

    使用场景:

    1>程序或模块内部使用抽象类

    2>程序架构或模块之间使用接口

    总结

    1 抽象类:

    ​ 实例化对象没有意思,所以使用抽象类,

    ​ 抽象类不能实例化

    2 abstract关键字

    ​ abstract 修饰类表示抽象类

    ​ abstract 修饰方法 抽象方法

    4 抽象方法

    ​ 抽象方法没有方法体

    ​ 抽象方法被子类重写

    ​ 包含抽象方法的类一定是抽象类

    5 抽象类

    ​ 抽象类不能实例化对象

    ​ 抽象类可以包含抽象方法,也可以包含非抽象方法

    ​ 抽象类的抽象方法必须被子类重写,除非子类也是抽象类

    6 static final abstract

    ​ final 和 abstract 不能一起使用

    ​ static和abstract不能一起使用

    7接口 :语法:就是特殊的抽象类

    ​ 功能:表示一个约定或能力

    ​ 接口好处:

    • 扩展类的功能,保持对外接口一致
    • 接口实现了多重继承,完成类和任何实现接口子类的通信和交互
    • 降低代码之间的耦合性

    定义接口

    ​ public interface 接口名{

    ​ 常量

    ​ 抽象方法

    ​ }

    ​ jdk1.8 静态方法和默认方法

    实现接口

    ​ class 类名 implements 接口名{

    ​ 重写接口中抽象方法

    ​ }

    ​ 一个类可以实现多个接口,只能继承一个类

    接口与接口的关系: extends ,多继承

    public interface Inter1{

    }

    public interface Inter2{

    }

    public interface Inter3 extends Inter1,Inter2{

    }

    接口案例:

    ​ Usb案例 表示接口是一个约定

    ​ 开火案例 表示接口是一个能力

    作业

    1 .案例:有一个小型企业,有技术员、销售员、销售经理和经理四类员工,这些员工都有编号、 姓名、工资、工资级别信息,
    技术员(Technology)的工资 每小时酬金(hourlyPay)与每个月工作时数(hours)积
    销售员(Salesman)的工资 每个月销售提成(bonus)与销售额(sales)积
    销售经理(SalesManager)工资 部门销售总额(sales),经理提成(bonus)的乘积并加固定月薪(monthlyPay)
    经理(Manager)工资 固定月薪(monthlyPay)

    工资级别:
    工资<3000 1
    3001~5000 2
    5001~8000 3
    工资>8000 4

    所有员工自动编号
    显示每个员工的信息,格式如下:
    编号是xxxx的员工(技术员、销售员、销售经理、经理)的姓名是xxx,工资是xxx,工资级别是xx

    2.编写抽象类手机 属性:brand ,type,功能:打电话,发短信,获取手机信息,子类有普通手机和智能手机,智能手机具有拍照,上网,播放音乐,播放视频功能。

    面试题

    接口和抽象类有什么区别?

    展开全文
  • 抽象类(abstract class)和接口(interface)的概念是面向对象设计中常用的概念, 也是比较容易混淆的概念. 在这里, 我提出一种区分它们的思路
  • 命名空间

    千次阅读 2012-11-24 10:57:33
    .NET Framework 类库提供了下列命名空间,并在此参考文档中详细介绍。 Accessibility 包含属于组件对象模型 (COM) 辅助功能接口的托管包装的一部分的类型。 Microsoft.Aspnet.Snapin 包含 ASP.NET 管理控制台...

    .NET Framework 类库提供了下列命名空间,并在此参考文档中详细介绍。

    Accessibility

    包含属于组件对象模型 (COM) 辅助功能接口的托管包装的一部分的类型。

    Microsoft.Aspnet.Snapin

    包含 ASP.NET 管理控制台应用程序与 Microsoft 管理控制台 (MMC) 交互所必需的类。

    Microsoft.Build.BuildEngine

    包含表示 MSBuild 引擎的类。

    Microsoft.Build.Conversion

    包含 Visual Studio 用来转换项目文件的类型。

    Microsoft.Build.Framework

    包含组成 MSBuild 的任务、记录器和事件的类。

    Microsoft.Build.Tasks

    包含 MSBuild 附带的所有任务的实现。

    Microsoft.Build.Tasks.Deployment.Bootstrapper

    包含由 MSBuild 在内部使用的类。

    Microsoft.Build.Tasks.Deployment.ManifestUtilities

    包含由 MSBuild 在内部使用的类。

    Microsoft.Build.Tasks.Hosting

    包含由 MSBuild 在内部使用的类。

    Microsoft.Build.Tasks.Windows

    包含由 MSBuild 在内部使用的类。

    Microsoft.Build.Utilities

    提供可用于创建您自己的 MSBuild 记录器和任务的帮助器类。

    Microsoft.CSharp

    包含支持用 C# 语言进行编译和代码生成的类。

    Microsoft.Ink

    包含在 Tablet PC 上实现数字墨迹的类型。

    Microsoft.JScript

    包含支持用 JScript 语言进行编译和代码生成的类。

    Microsoft.ServiceModel.Channels.Mail

    包含在 .NET Compact Framework 上和使用基于 Windows Communication Foundation (WCF) 的 Exchange Server 邮件传输的桌面上支持编程应用的类。

    Microsoft.ServiceModel.Channels.Mail.ExchangeWebService

    包含通过使用 .NET Framework 在桌面上提供 Microsoft Exchange Server 邮件传输的实现的类。

    Microsoft.ServiceModel.Channels.Mail.WindowsMobile

    包含在使用 .NET Compact Framework 的 Windows Mobile 设备上提供 Microsoft Exchange Server 邮件传输的实现的类。

    Microsoft.SqlServer.Server

    包含专用于 .NET Framework 公共语言运行库 (CLR) 组件与 Microsoft SQL Server 和 SQL Server 数据库引擎进程执行环境的集成的类。

    Microsoft.StylusInput

    包含用于实时处理来自数字化仪的手写笔数据包数据的类型。

    Microsoft.StylusInput.PluginData

    包含表示传递给 RealTimeStylus 插件的数据的类型。

    Microsoft.VisualBasic

    包含支持用 Visual Basic 语言进行编译和代码生成的类。

    Microsoft.VisualBasic.ApplicationServices

    包含支持 Visual Basic 应用程序模型并提供对应用程序信息的访问的类型。

    Microsoft.VisualBasic.Compatibility.VB6

    包含一些工具在将 Visual Basic 6.0 升级到 Visual Basic .NET 时所使用的类型。

    Microsoft.VisualBasic.CompilerServices

    包含支持 Visual Basic 编译器的仅供内部使用的类型。

    Microsoft.VisualBasic.Devices

    包含支持与 Visual Basic 中的设备相关的 My 对象的类型。

    Microsoft.VisualBasic.FileIO

    包含支持 Visual Basic 中的 My 文件系统对象的类型。

    Microsoft.VisualBasic.Logging

    包含支持 Visual Basic 中的 My 日志记录对象的类型,并提供可将日志记录输出定向到文件的简单日志侦听器。

    Microsoft.VisualBasic.MyServices

    包含支持 Visual Basic 中的 My 的类型。

    Microsoft.VisualBasic.MyServices.Internal

    包含支持 Visual Basic 中的 My 的仅供内部使用的类型。

    Microsoft.VisualC

    包含支持 Visual C++ 编译器的类型。 

    Microsoft.VisualC.StlClr

    包含用于实现 STL/CLR 库的类型。

    Microsoft.VisualC.StlClr.Generic

    包含用于实现 STL/CLR 库的泛型接口的类型。

    Microsoft.Vsa

    包含使您可以将 .NET Framework 脚本引擎的脚本集成到应用程序中并在运行时编译和执行代码的接口。

    Microsoft.Web.Administration

    包含用于管理 Internet 信息服务 (IIS) 管理器的类。

    Microsoft.Web.Management.Client

    包含用于在 IIS 管理器中显示的开发工具的类。

    Microsoft.Web.Management.Client.Extensions

    包含用于扩展 IIS 管理器中的功能的类。

    Microsoft.Web.Management.Client.Win32

    包含用于为在 IIS 管理器中显示的工具创建 Windows 窗体的用户界面类。

    Microsoft.Web.Management.Features.Administrators

    包含用于标识管理员模块的类。

    Microsoft.Web.Management.Features.Delegation

    包含用于标识委托模块的类。

    Microsoft.Web.Management.Features.Service

    包含用于标识管理服务模块的类。

    Microsoft.Web.Management.Host

    包含用于标识管理单元的宿主的接口。

    Microsoft.Web.Management.Host.Shell

    包含用于启动 IIS 管理器并向其传递信息的类。

    Microsoft.Web.Management.Server

    包含用于在 IIS 管理器中实现管理功能的服务器部分的类型。

    Microsoft.Win32

    提供两种类型的类:处理由操作系统引发的事件的类和对系统注册表进行操作的类。

    Microsoft.Win32.SafeHandles

    包含安全句柄类的抽象派生类,安全句柄类提供支持文件和操作系统句柄的常见功能。

    Microsoft.Windows.Themes

    公开一组由 Windows Presentation Foundation (WPF) 定义的主题。

    Microsoft.WindowsCE.Forms

    包含用于使用 .NET Compact Framework 开发 Pocket PC 和 Smartphone Windows 窗体应用程序的类。

    Microsoft.WindowsMobile.DirectX

    包含用于开发带有 .NET Compact Framework 的设备上使用的 DirectX 应用程序的类。

    Microsoft.WindowsMobile.DirectX.Direct3D

    包含用于开发带有 .NET Compact Framework 的设备上使用的 Direct3D 应用程序的类。

    System

    包含用于定义常用值和引用数据类型、事件和事件处理程序、接口、属性和处理异常的基础类和基类。其他类提供支持下列操作的服务:数据类型转换,方法参数操作,数学计算,远程和本地程序调用,应用程序环境管理以及对托管和非托管应用程序的监管。

    System.AddIn

    包含用于标识外接程序的属性。

    System.AddIn.Contract

    包含为独立更新的组件之间的通信提供基础的类型。

    System.AddIn.Contract.Automation

    包含组件用于访问类型信息和调用类型成员的类型。

    System.AddIn.Contract.Collections

    包含用于实现外接程序开发所用的集合类的类型。

    System.AddIn.Hosting

    提供用于发现、注册、激活和控制外接程序的类型。

    System.AddIn.Pipeline

    提供用于在宿主应用程序与外接程序之间构造通信管线的类。

    System.CodeDom

    包含可用于表示源代码文档的元素和结构的类。这些元素可用于为源代码文档建立结构模型。通过使用 System.CodeDom.Compiler 命名空间所提供的功能,可以将源代码文档输出为用受支持的语言编写的源代码。

    System.CodeDom.Compiler

    包含用于管理用受支持的编程语言生成和编译源代码的类型。每个代码生成器都可以基于代码文档对象模型 (CodeDOM) 源代码模型(由 System.CodeDom 命名空间提供的元素组成)的结构来生成使用某种特定的编程语言的源代码。

    System.Collections

    包含定义各种对象集合(如列表、队列、位数组、哈希表和字典)的接口和类。

    System.Collections.Generic

    包含用于定义泛型集合的接口和类;泛型集合允许用户创建强类型的集合,这种集合在类型安全和性能上均优于非泛型强类型集合。

    System.Collections.ObjectModel

    包含能在可重用库的对象模型中用作集合的类。在属性或方法返回集合时使用这些类。

    System.Collections.Specialized

    包含专用的强类型集合;例如,链接表词典、位向量以及只包含字符串的集合。

    System.ComponentModel

    提供用于实现组件和控件的运行时和设计时行为的类。此命名空间包括用于属性和类型转换器的实现、数据源绑定和组件授权的基类和接口。

    System.ComponentModel.Design

    包含可由开发人员用来生成自定义设计时组件行为和在设计时配置组件的用户界面的类。设计时环境提供了使开发人员能够安排组件并配置它们的属性的系统。

    System.ComponentModel.Design.Data

    包含用于实现数据相关的组件的设计时行为的类。

    System.ComponentModel.Design.Serialization

    提供支持在设计时自定义和控制序列化的类型。

    System.Configuration

    包含提供用于处理配置数据的编程模型的类型。

    System.Configuration.Assemblies

    包含用于配置程序集的类。

    System.Configuration.Install

    提供使您可以为自己的组件编写自定义安装程序的类。Installer 类是 .NET Framework 中所有自定义安装程序的基类。

    System.Configuration.Provider

    包含由服务器和客户端应用程序共享以支持可插接式模型轻松地添加或移除功能的基类。

    System.Data

    包含组成大部分 ADO.NET 结构的类。ADO.NET 结构使您可以生成可用于有效管理来自多个数据源的数据的组件。

    System.Data.Common

    包含由 .NET Framework 数据提供程序共享的类。.NET Framework 数据提供程序描述用于在托管空间中访问数据源(如数据库)的类的集合。

    System.Data.Design

    包含可用于生成自定义的类型化数据集的类。

    System.Data.Linq

    包含支持在 LINQ to SQL 应用程序中与关系数据库进行交互的类。

    System.Data.Linq.Mapping

    包含用于生成表示关系数据库的结构和内容的 LINQ to SQL 对象模型的类。

    System.Data.Odbc

    包含封装 ODBC .NET Framework 数据提供程序的类。ODBC .NET Framework 数据提供程序描述了用于在托管空间中访问 ODBC 数据源的类集合。

    System.Data.OleDb

    包含封装 OLE DB .NET Framework 数据提供程序的类。OLE DB .NET Framework 数据提供程序描述了用于在托管空间中访问 OLE DB 数据源的类集合。

    System.Data.OracleClient

    包含封装 Oracle .NET Framework 数据提供程序的类。Oracle .NET Framework 数据提供程序描述了用于在托管空间中访问 Oracle 数据源的类集合。

    System.Data.Sql

    包含支持特定于 SQL Server 的功能的类。此类的 API 扩展已添加到 SQL Server 的 .NET Framework 数据提供程序 (System.Data.SqlClient) 中。

    System.Data.SqlClient

    包含封装 SQL Server .NET Framework 数据提供程序的类。SQL Server .NET Framework 数据提供程序描述了用于在托管空间中访问 SQL Server 数据库的类集合。

    System.Data.SqlServerCe

    描述可用于在托管环境下从基于 Windows CE 的设备访问 SQL Server CE 中的数据库的类集合。通过此命名空间,可以在一个设备上创建 SQL Server CE 数据库,并且可以与另一个设备或远程服务器上的 SQL Server 数据库建立连接。

    System.Data.SqlTypes

    包含用于 SQL Server 中的本机数据类型的类。这些类提供了其他数据类型的更快速的替代方式。使用此命名空间中的类有助于防止在可能发生精度损失的情况中出现的类型转换错误。由于其他数据类型与 SqlTypes 在后台相互转换,因此在此命名空间内显式创建和使用对象同样会产生较快的代码。

    System.Deployment.Application

    提供用于在 ClickOnce 应用程序中创建自定义升级行为的类型。

    System.Diagnostics

    提供使您可以与系统进程、事件日志和性能计数器进行交互的类。此命名空间还提供了可让您调试应用程序并跟踪代码执行的类。

    System.Diagnostics.CodeAnalysis

    包含用于与代码分析工具交互的类。代码分析工具用于分析代码是否符合诸如命名和安全规则之类的编码约定。

    System.Diagnostics.Design

    包含可用于扩展应用程序监视和检测的设计时支持的类。

    System.Diagnostics.Eventing

    包含支持在 Windows Vista 上实现应用程序的类型。检测功能(在启用时)会将事件数据记录到 Windows 事件跟踪 (ETW) 跟踪子系统中。

    System.Diagnostics.Eventing.Reader

    包含支持从事件日志中读取信息并管理事件日志的类型。

    System.Diagnostics.PerformanceData

    包含用于提供计数器数据的类,计数器数据会将性能度量值向使用者公开。

    System.Diagnostics.SymbolStore

    提供使您可以读取和写入调试符号信息(如 Microsoft 中间语言 (MSIL) 映射到的源行)的类。面向 .NET Framework 的编译器可以将调试符号信息存储到程序员的数据库 (PDB) 文件中。调试器和代码探查器工具可以在运行时读取调试符号信息。

    System.DirectoryServices

    提供从托管代码轻松访问 Active Directory 的方法。该命名空间包含两个组件类,即 DirectoryEntryDirectorySearcher,它们使用 Active Directory 服务接口 (ADSI) 技术。ADSI 是由 Microsoft 提供的一组接口,是一种可灵活处理各种网络提供程序的工具。无论网络有多大,ADSI 都可以使管理员能够相对容易地定位和管理网络上的资源。

    System.DirectoryServices.AccountManagement

    跨多个主体存储区提供用户、计算机和组安全主体的统一访问和操作。

    System.DirectoryServices.ActiveDirectory

    提供围绕 Active Directory 目录服务任务构建的高级别抽象对象模型。Active Directory 目录服务概念(如目录林、域、网站、子网、分区和架构)都属于对象模型的组成部分。

    System.DirectoryServices.Protocols

    提供在轻型目录访问协议 (LDAP) 版本 3 和目录服务标记语言 (DSML) 版本 2.0 标准中定义的方法。

    System.Drawing

    提供对 GDI+ 基本图形功能的访问。System.Drawing.Drawing2DSystem.Drawing.ImagingSystem.Drawing.Text 命名空间中提供了更高级的功能。

    System.Drawing.Design

    包含扩展设计时用户界面 (UI) 逻辑和绘制的类。可以进一步扩展此设计时功能来创建以下对象:自定义工具箱项,类型特定的值编辑器或类型转换器,其中类型特定的值编辑器用于编辑和以图形方式表示所支持的类型的值;类型转换器用于在特定的类型之间转换值。此命名空间提供了开发设计时用户界面扩展的基本框架。

    System.Drawing.Drawing2D

    提供高级的二维和矢量图形功能。此命名空间包含渐变画笔、Matrix 类(用于定义几何变换)和 GraphicsPath 类。

    System.Drawing.Imaging

    提供高级的 GDI+ 图像处理功能。基本图形功能由 System.Drawing 命名空间提供。

    System.Drawing.Printing

    提供与打印相关的服务。通常情况下,您可以创建 PrintDocument 类的新实例,设置描述打印内容的属性,然后调用 Print 方法来实际打印文档。

    System.Drawing.Text

    提供高级的 GDI+ 版式功能。基本图形功能由 System.Drawing 命名空间提供。此命名空间中的类使用户可以创建和使用字体集合。

    System.EnterpriseServices

    为企业级应用程序提供重要的基础结构。COM+ 为企业级环境中部署的组件编程模型提供服务结构。此命名空间为 .NET Framework 对象提供了对 COM+ 服务的访问,从而使 .NET Framework 对象更适用于企业级应用程序。

    System.EnterpriseServices.CompensatingResourceManager

    提供使您可以在托管代码中使用补偿资源管理器 (CRM) 的类。CRM 是由 COM+ 提供的一项服务,它使您可以在 Microsoft 分布式事务处理协调器 (DTC) 事务中包括非事务性对象。虽然 CRM 不提供完整资源管理器的功能,但它们却通过恢复日志提供事务性原子性(全有或全无行为)和持久性。

    System.Globalization

    包含定义区域性相关信息的类;这些信息包括语言,国家/地区,正在使用的日历,日期、货币和数字的格式模式以及字符串的排序顺序。这些类对于编写全球化(国际化)应用程序很有用。

    System.IdentityModel.Claims

    包含支持在可扩展标识模型中使用声明的类型。

    System.IdentityModel.Policy

    包含用于在 Windows Communication Foundation (WCF) 中生成或使用授权策略的类型。

    System.IdentityModel.Selectors

    包含用于为传出的 SOAP 消息提供安全令牌和验证传入的 SOAP 消息中的安全令牌的类型。

    System.IdentityModel.Tokens

    包含与 Windows Communication Foundation (WFC) 附带的预定义安全令牌相关的类型。

    System.IO

    包含允许对数据流和文件进行同步和异步读写的类型。

    System.IO.Compression

    包含提供基本的流压缩和解压缩的类。

    System.IO.IsolatedStorage

    包含支持创建和使用独立存储区的类型。通过使用这些存储区,可以读取和写入受信任程度较小的代码无法访问的数据,并且有助于防止公开可保存在文件系统中其他位置的敏感信息。数据存储在独立于当前用户和代码所在的程序集的隔离舱中。

    System.IO.Log

    包含用于实现自定义诊断日志记录或事务处理系统的类型。

    System.IO.Packaging

    包含支持在单个容器中存储多个数据对象的类型。

    System.IO.Pipes

    包含一些类型,这些类型提供一种通过匿名和/或命名管道进行进程间通信的方法。

    System.IO.Ports

    包含控制串行端口的类,提供用于同步和事件驱动的 I/O 的框架、对插针和中断状态的访问、对串行驱动程序属性的访问以及用于指定端口特征的枚举。

    System.Linq

    包含支持使用语言集成查询 (LINQ) 的查询的类和接口。

    System.Linq.Expressions

    包含可使语言级别的代码表达式表示为表达式目录树形式的对象的类型。

    System.Management

    提供对一组丰富的管理信息和管理事件(它们是关于符合 Windows Management Instrumentation (WMI) 基础结构的系统、设备和应用程序的)的访问。

    System.Management.Instrumentation

    提供一些类,检测管理应用程序以及通过 WMI 向潜在使用者公开管理信息和事件时需要这些类。

    System.Media

    包含用于播放声音文件和访问系统声音的类。

    System.Messaging

    提供使您可以连接、监视和管理网络上的消息队列以及发送、接收或查看消息的类。

    System.Messaging.Design

    包含可用于扩展 System.Messaging 类设计时支持的类。

    System.Net

    为当前网络采用的多种协议提供简单的编程接口。WebRequestWebResponse 类形成了所谓的可插接式协议的基础,可插接式协议是网络服务的一种实现,使您能够开发出使用 Internet 资源的应用程序,而不必考虑各种协议的具体细节。

    System.Net.Cache

    定义类型和枚举,这些类型和枚举用于为使用 WebRequestHttpWebRequest 类获得的资源定义缓存策略。

    System.Net.Configuration

    包含应用程序以编程方式访问和更新 System.Net 命名空间的配置设置所用的类。

    System.Net.Mail

    包含用于将电子邮件发送到简单邮件传输协议 (SMTP) 服务器以进行传送的类。

    System.Net.Mime

    包含用于表示多用途 Internet 邮件交换 (MIME) 标头的类型。这些类型与 System.Net.Mail 命名空间中的类型配合使用,可在使用 SmtpClient 类发送电子邮件时指定 Content-Type、Content-Disposition 和 Content-transfer-Encoding 等标头。

    System.Net.NetworkInformation

    提供对网络流量数据、网络地址信息和本地计算机地址变更通知的访问。该命名空间还包含实现 Ping 实用工具的类。可以使用 Ping 和相关的类检查是否可通过网络访问计算机。

    System.Net.Security

    包含提供用于主机间安全通信的网络流的类型。

    System.Net.PeerToPeer

    提供对对等网络功能的访问。

    System.Net.PeerToPeer.Collaboration

    提供用于增强对等网络功能并赋予无服务器托管协作会话功能的类型。

    System.Net.Security

    提供用于主机间安全通信的网络流。

    System.Net.Sockets

    为需要帮助控制网络访问的开发人员提供 Windows 套接字 (Winsock) 接口的托管实现。

    System.Printing

    包含支持打印的类型。

    System.Printing.IndexedProperties

    包含提供对打印系统对象的属性的访问(不使用反射)并允许快速将属性设置复制到同一类型的另一个对象的类。

    System.Printing.Interop

    提供支持托管 PrintTicket 对象与非托管图形设备接口 (GDI) DEVMODE 结构之间的相互转换的类型。

    System.Reflection

    包含提供已加载类型、方法和字段的托管视图的类和接口,并具有动态创建和调用类型的能力。

    System.Reflection.Emit

    包含允许编译器或工具发出元数据和 Microsoft 中间语言 (MSIL) 并在磁盘上生成 PE 文件(可选)的类。这些类的主要客户端是脚本引擎和编译器。

    System.Resources

    提供允许开发人员创建、存储和管理应用程序中使用的各种区域性特定资源的类和接口。

    System.Resources.Tools

    包含 StronglyTypedResourceBuilder 类,该类提供对强类型资源的支持。从 .NET Framework 2.0 版开始,此编译时功能通过创建包含一组静态只读 (get) 属性的类封装对资源的访问,从而更容易使用资源。

    System.Runtime

    包含支持不同命名空间的高级类型,例如 SystemRuntime 命名空间和 Security 命名空间。

    System.Runtime.CompilerServices

    为使用托管代码的编译器编写器提供功能,以在影响公共语言运行库的运行时行为的元数据中指定属性。此命名空间中的类只用于编译器编写器。

    System.Runtime.ConstrainedExecution

    定义一组类型,在特定代码的作者和利用该代码依赖项的开发人员之间枚举和定义可靠性协定。这些类型仅用于受约束执行区域 (CER)。

    System.Runtime.Hosting

    包含用于应用程序域中的应用程序激活的高级类型。

    System.Runtime.InteropServices

    提供各种支持 COM 互操作和平台调用服务的成员。如果对这些服务不熟悉,请参见与非托管代码交互操作

    System.Runtime.InteropServices.ComTypes

    包含作为托管代码的 COM 函数定义的方法。这些函数取代了 System.Runtime.InteropServices 命名空间中现已过时的 UCOM 方法。

    System.Runtime.InteropServices.Expando

    包含 IExpando 接口,此接口允许通过添加或移除对象的成员来修改对象。

    System.Runtime.Remoting

    提供允许开发人员创建和配置分布式应用程序的类和接口。

    System.Runtime.Remoting.Activation

    提供支持服务器和客户端远程对象激活的类和对象。

    System.Runtime.Remoting.Channels

    包含支持和处理信道和信道接收器的类,这些信道和信道接收器在客户端对远程对象调用方法时用作传输媒介。

    System.Runtime.Remoting.Channels.Http

    包含使用 HTTP 协议与远程位置之间相互传输消息和对象的信道。默认情况下,HTTP 信道以 SOAP 格式对对象和方法调用进行编码以便传输,但在信道的配置属性中也可以指定其他编码和解码格式化程序接收器。

    System.Runtime.Remoting.Channels.Ipc

    定义用于远程处理的通信信道,该信道使用 Windows 操作系统的进程间通信 (IPC) 系统。由于未使用网络通信,IPC 信道要比 HTTP 和 TCP 信道快得多,但是它只能用于相同物理计算机上的应用程序域之间的通信。

    System.Runtime.Remoting.Channels.Tcp

    包含使用 TCP 协议与远程位置之间相互传输消息和对象的信道。默认情况下,TCP 信道以二进制格式对对象和方法调用进行编码以便传输,但在信道的配置属性中也可以指定其他编码和解码格式化程序接收器。

    System.Runtime.Remoting.Contexts

    包含定义所有对象所驻留的上下文的对象。上下文是一个有序的属性序列,用于定义其中的对象所处的环境。上下文是在对象的激活过程中创建的,这些对象被配置为要求某些自动服务,如同步、事务、实时 (JIT) 激活、安全性等。多个对象可以存留在一个上下文内。

    System.Runtime.Remoting.Lifetime

    包含管理远程对象生存期的类。传统上,分布式垃圾回收功能使用引用计数和 Ping 来控制对象的生存期。这种机制在每一项服务只有较少的客户端时可以正常工作,但是当每一项服务有几千个客户端时就不能正常工作了。远程处理生存期服务将每一项服务与一个租约关联,当租约到期时,就会删除该服务。生存期服务可以起到传统的分布式垃圾回收器的作用,并且当每一项服务的客户端数量增加时也能很好地调整。

    System.Runtime.Remoting.Messaging

    包含用于创建和远程处理消息的类。远程处理基础结构使用消息与远程对象进行通信。消息用于传输远程方法调用、激活远程对象和交流信息。消息对象携带一组命名属性,其中包括操作标识符、代表信息和参数。

    System.Runtime.Remoting.Metadata

    包含可用于为对象和字段自定义 SOAP 的生成和处理的类和属性。此命名空间中的类可用于指示 SOAPAction、类型输出、XML 元素名和 XML 命名空间统一资源标识符 (URI) 方法。

    System.Runtime.Remoting.Metadata.W3cXsd2001

    包含由万维网联合会 (W3C) 在 2001 年定义的 XML 架构定义 (XSD)。W3C 的 XML Schema Part 2: Datatypes(XML 架构第二部分:数据类型)规范确定了各种数据类型的格式和行为。此命名空间包含符合 W3C 规范的数据类型的包装类。所有日期和时间类型都符合 ISO 标准规范。

    System.Runtime.Remoting.MetadataServices

    包含由 Soapsuds.exe 命令行工具和用户代码用来在元数据和远程处理基础结构的 XML 架构之间相互转换的类。

    System.Runtime.Remoting.Proxies

    包含控制和提供代理功能的类。代理是作为远程对象映像的本地对象。代理使客户端可以跨远程处理边界访问对象。

    System.Runtime.Remoting.Services

    包含为 .NET Framework 提供功能的服务类。

    System.Runtime.Serialization

    包含可用于序列化和反序列化对象的类。序列化是将对象或对象图转换为线性的字节序列以存储或传输到其他位置的过程。反序列化是接受存储的信息并用这些信息重新创建对象的过程。

    System.Runtime.Serialization.Configuration

    包含用于读取应用程序配置文件中的 <system.xml.serialization> 节中的值的类。

    System.Runtime.Serialization.Formatters

    提供由序列化格式化程序使用的通用枚举、接口和类。

    System.Runtime.Serialization.Formatters.Binary

    包含 BinaryFormatter 类,该类可用于以二进制格式将对象序列化和反序列化。

    System.Runtime.Serialization.Formatters.Soap

    包含 SoapFormatter 类,该类可用于以 SOAP 格式将对象序列化和反序列化。

    System.Runtime.Serialization.Json

    包含用于将对象序列化为 JavaScript 对象表示法 (JSON) 和从 JSON 反序列化对象的类型。

    System.Runtime.Versioning

    包含支持在 .NET Framework 的多个实现中进行版本控制的高级类型。

    System.Security

    提供 .NET Framework 安全系统的基础结构,包括权限的基类。

    System.Security.AccessControl

    提供用于控制对可保护对象的访问并审核针对这些对象执行的安全相关操作的编程元素。

    System.Security.Authentication

    提供一组描述连接安全性的枚举。

    System.Security.Cryptography

    提供加密服务,包括数据的安全编码和解码,以及其他许多操作,如哈希处理、随机数生成和消息身份验证。

    System.Security.Cryptography.Pkcs

    提供公钥加密标准 (PKCS) 的编程元素,包括用于签名数据、交换密钥、请求证书、公钥加密和解密以及其他安全功能的方法。

    System.Security.Cryptography.X509Certificates

    包含 Authenticode X.509 v.3 证书的公共语言运行库实现。此证书用唯一明确标识证书持有者的私钥签名。

    System.Security.Cryptography.Xml

    包含支持创建和验证 XML 数字签名的类。

    System.Security.Permissions

    定义根据策略控制操作和资源访问的类。

    System.Security.Policy

    包含代码组、成员条件和证据。这三种类型的类用于创建由 .NET Framework 安全策略系统应用的规则。证据类是安全策略的输入,而成员条件是开关;二者共同创建策略语句并确定授予的权限集。策略级别和代码组是策略层次的结构。代码组是规则的封装并且在策略级别中分层排列。

    System.Security.Principal

    定义表示运行代码的安全上下文的主体对象。

    System.Security.RightsManagement

    包含支持对应用程序创建的内容(例如存储在 Package 或 XpsDocument 中的文本)进行权限管理的类。

    System.ServiceModel

    包含生成 Windows Communication Foundation (WCF) 服务和可以用于生成广泛分布的应用程序的客户端应用程序所必需的类型。

    System.ServiceModel.Activation

    包含在托管宿主环境中构造和修改服务宿主的动态创建所需要的类型。

    System.ServiceModel.Activation.Configuration

    包含用于表示 SMSvcHost.exe.config 文件中的配置元素的类。

    System.ServiceModel.Channels

    包含构造和修改由客户端和服务用来相互通信的消息所需要的类型、用于交换消息的信道的类型、用于这些信道的信道工厂和信道侦听器以及用于配置它们的绑定元素。

    System.ServiceModel.ComIntegration

    包含将 Windows Communication Foundation (WCF) 服务和客户端应用程序与 COM 组件集成所必需的类型。

    System.ServiceModel.Configuration

    包含 Windows Communication Foundation (WCF) 基础结构将 XML 转换为公共语言运行库 (CLR) 类型时所使用的类型。

    System.ServiceModel.Description

    包含构造和修改服务、协定和终结点(用于生成运行库和导出元数据)的说明所需要的类型。

    System.ServiceModel.Diagnostics

    包含用于配置诊断目的的性能计数器的枚举。

    System.ServiceModel.Dispatcher

    包含修改服务和客户端应用程序的运行时执行行为所需要的类型。

    System.ServiceModel.Install.Configuration

    包含用于安装和配置有关在计算机上运行 Windows Communication Foundation (WCF) 的各种配置设置的类。

    System.ServiceModel.MsmqIntegration

    包含用于 Microsoft 消息队列服务 (MSMQ) 集成的类,此集成允许 MSMQ 应用程序与 Windows Communication Foundation (WCF) 应用程序进行通信。

    System.ServiceModel.PeerResolvers

    System.ServiceModel.Persistence

    System.ServiceModel.Security

    包含支持常规 Windows Communication Foundation (WCF) 安全的类。

    System.ServiceModel.Security.Tokens

    包含表示安全令牌和 Windows Communication Foundation (WCF) 安全的证书的类型。

    System.ServiceModel.Syndication

    包含构成整合对象模型的类型。

    System.ServiceModel.Web

    包含构成 Web HTTP 编程模型的类型。

    System.ServiceProcess

    提供使您可以实现、安装和控制 Windows 服务应用程序的类。服务是长期运行的可执行文件,它们不通过用户界面来运行。实现服务涉及以下方面:从 ServiceBase 类继承,定义在传入开始、停止、暂停和继续命令时要处理的特定行为,以及定义在系统关闭时要执行的自定义行为和操作。

    System.ServiceProcess.Design

    包含可用于扩展对 Windows 服务应用程序的设计时支持的类。

    System.Speech.AudioFormat

    System.Speech.Recognition

    包含用于实现语音识别的 Windows 桌面语音技术类型。

    System.Speech.Recognition.SrgsGrammar

    System.Speech.Synthesis

    System.Speech.Synthesis.TtsEngine

    包含支持基于语音合成标记语言 (SSML) 创建用于呈现文本到语音 (TTS) 的自定义引擎的类型。

    System.Text

    包含表示 ASCII、Unicode、UTF-7 和 UTF-8 字符编码的类;用于在字符块和字节块之间相互转换的抽象基类;以及不需要创建 String 的中间实例就可以操作和格式化 String 对象的帮助器类。

    System.Text.RegularExpressions

    包含提供对 .NET Framework 正则表达式引擎的访问的类。此命名空间提供的正则表达式功能可在 .NET Framework 中运行的任何平台或语言上使用。

    System.Threading

    提供支持多线程编程的类和接口。除了同步线程活动和数据访问的类(MutexMonitorInterlockedAutoResetEvent 等)外,此命名空间还包含一个 ThreadPool 类(可让您使用系统提供的线程池)和一个 Timer 类(在线程池线程上执行回调方法)。

    System.Timers

    提供允许按指定的间隔引发事件的 Timer 组件。

    System.Transactions

    包含允许您的代码参与事务的类。这些类支持具有分散各处的多名参加人、多阶段通知和可持续登记的事务。

    System.Transactions.Configuration

    包含描述 System.Transactions 类使用的配置选项的类。

    System.Web

    提供启用浏览器/服务器通信的类和接口。此命名空间包括提供有关当前 HTTP 请求的广泛信息的 HttpRequest 类、管理对客户端的 HTTP 输出的 HttpResponse 类以及提供对服务器端实用工具和进程的访问的 HttpServerUtility 类。System.Web 还包括用于 Cookie 操作、文件传输、异常信息和输出缓存控制的类。

    System.Web.ApplicationServices

    提供可用于访问 ASP.NET 窗体身份验证、角色和配置文件应用程序服务(例如 Windows Communication Foundation (WCF) 服务)的类。

    System.Web.Caching

    提供用于在服务器上缓存常用数据的类。其中包含 Cache 类,该类是一个字典,您可以在其中存储任意数据对象,如哈希表和数据集。它还为这些对象提供了失效功能,并为您提供了添加和移除这些对象的方法。您也可以添加依赖于其他文件或缓存项的对象,并在某个对象从缓存中被移除时执行回调以通知您的应用程序。

    System.Web.ClientServices

    包含支持从基于 Windows 的应用程序访问 ASP.NET 登录、角色和配置文件服务的类。

    System.Web.ClientServices.Providers

    包含支持从基于 Windows 的应用程序中访问 ASP.NET 登录、角色和配置文件服务的客户端服务提供程序和其他类。

    System.Web.Compilation

    包含用于生成和编译 ASP.NET 生成环境中的自定义文件类型的类。

    System.Web.Configuration

    包含用于设置 ASP.NET 配置的类。

    System.Web.Handlers

    包含 HTTP 处理程序类,这些类处理对 Web 服务器的 HTTP 请求。

    System.Web.Hosting

    提供从 Microsoft Internet 信息服务 (IIS) 的外部托管应用程序承载 ASP.NET 应用程序的功能。

    System.Web.Management

    包含用于管理和监视 Web 应用程序的运行状况的类和接口。

    System.Web.Mobile

    包含生成 ASP.NET 移动 Web 应用程序所需的核心功能,其中包括身份验证和错误处理。

    System.Web.Profile

    包含用于在 Web 服务器应用程序中实现 ASP.NET 用户配置文件的类。

    System.Web.Query.Dynamic

    包含可用于将 LinqDataSource 控件中的表达式分析为语言集成查询 (LINQ) 的类。

    System.Web.RegularExpressions

    提供用于分析 ASP.NET 文件的正则表达式。System.Web.RegularExpressions 命名空间的所有成员都是 Regex 类的子代。

    System.Web.Script.Serialization

    此命名空间包含的类为托管类型提供 JavaScript 对象表示法 (JSON) 序列化和反序列化。还提供用于自定义序列化行为的扩展性功能。

    System.Web.Script.Services

    提供用于自定义对在 ASP.NET 中使用 AJAX 功能的 Web 服务支持的属性。

    System.Web.Security

    包含用于在 Web 服务器应用程序中实现 ASP.NET 安全的类。

    System.Web.Services

    包含使您可以利用 ASP.NET 和 XML Web services 客户端来创建 XML Web services 的类。XML Web services 是一些应用程序,它们提供了在使用标准协议(如 HTTP、XML、XSD、SOAP 和 WSDL)的松耦合环境下进行消息交换的能力。利用 XML Web services,可以在异质环境下的公司内部和公司之间生成模块化应用程序,使它们与各种各样的实现、平台和设备交互操作。

    System.Web.Services.Configuration

    由一些类组成,这些类配置用 ASP.NET 创建的 XML Web services 的运行方式。

    System.Web.Services.Description

    由一些类组成,这些类使您能够使用 Web 服务描述语言 (WSDL) 公开描述 XML Web services。此命名空间中的每个类对应于 WSDL 规范中的一个特定元素,并且类层次结构对应于有效的 WSDL 文档的 XML 结构。

    System.Web.Services.Discovery

    由一些类组成,这些类使 XML Web services 客户端可以通过称为“XML Web services 发现”的进程找到 Web 服务器上可用的 XML Web services。

    System.Web.Services.Protocols

    由一些类组成,这些类定义用于在通信期间通过网络在 XML Web services 客户端和用 ASP.NET 创建的 XML Web services 之间传输数据的协议。

    System.Web.SessionState

    提供支持在服务器上存储特定于 Web 应用程序中的单个客户端的数据的类和接口。会话状态数据用于向客户端提供与应用程序的持久连接的外观。状态信息可以存储在本地进程内存中,或者,对于网络场配置来说,可以使用 ASP.NET 状态服务或 SQL Server 数据库将状态信息存储在进程外。

    System.Web.UI

    提供可用于创建用作 ASP.NET Web 应用程序用户界面的 ASP.NET 服务器控件和 ASP.NET 网页的类和接口。此命名空间包含 Control 类,该类提供所有 HTML 服务器控件、Web 服务器控件和带有一组通用功能的用户控件。该类还包含 Page 控件,每当对 ASP.NET Web 应用程序中的 .aspx 页发出请求时,将会自动生成此控件。此外,此命名空间还包括为服务器控件提供数据绑定功能、保存给定控件或页的视图状态的功能以及分析功能的类。

    System.Web.UI.Adapters

    包含控件适配器和页适配器的基类,可使用这些适配器重写页和控件的生命周期状态,以针对新的标记标准或特定浏览器修改它们的默认标记或行为。

    System.Web.UI.Design

    包含可用于扩展 ASP.NET 网页和 Web 服务器控件设计时支持的类。

    System.Web.UI.Design.MobileControls

    已过时。包含为 System.Web.UI.MobileControls 命名空间中的类提供设计时支持的类。此命名空间中的类已过时;请改用 System.Web.UI.Design.WebControls 中的类。

    System.Web.UI.Design.MobileControls.Converters

    包含为移动控件中的数据类型转换器提供设计时支持的类。

    System.Web.UI.Design.WebControls

    包含可用于扩展 Web 服务器控件设计时支持的类。

    System.Web.UI.Design.WebControls.WebParts

    包含为从 System.Web.UI.WebControls.WebParts 命名空间中的类派生的控件提供设计时支持的类。

    System.Web.UI.HtmlControls

    包含使您可以在 Web 窗体页上创建 HTML 服务器控件的类集合。HTML 服务器控件运行在服务器上,并且直接映射到大多数浏览器所支持的标准 HTML 标记。这使您能够以编程方式控制 Web 窗体页上的 HTML 元素。

    System.Web.UI.MobileControls

    已过时。包含一组 ASP.NET 服务器控件,这些控件可以针对不同的移动设备智能地呈现您的应用程序。此命名空间中的类已过时;请改用 System.Web.UI.WebControls 中的控件。

    System.Web.UI.MobileControls.Adapters

    其中包含的类可用于重写移动控件的生命周期阶段,以便修改移动控件的默认 HTML、CHTML 或 WML 标记或行为,使其适应新的标记标准或特定浏览器和移动设备。

    System.Web.UI.MobileControls.Adapters.XhtmlAdapters

    其中包含的类可用于重写移动控件的生命周期阶段,以便修改移动控件的默认 XHTML 标记或行为,使其适应新的标记标准或特定浏览器和移动设备。

    System.Web.UI.WebControls

    包含使您可以在网页上创建 Web 服务器控件的类。Web 服务器控件运行在服务器上,并且包括按钮和文本框等窗体控件。它们还包括具有特殊用途的控件(例如日历)。由于 Web 服务器控件运行在服务器上,因此可以以编程方式来控制这些元素。Web 服务器控件比 HTML 服务器控件更抽象。它们的对象模型不一定反映 HTML 语法。

    System.Web.UI.WebControls.Adapters

    其中包含的类可用于重写 Web 控件的生命周期阶段,以便修改控件的默认标记或行为,使其适应新的标记标准或特定浏览器。

    System.Web.UI.WebControls.WebParts

    包含类和接口的一个完整集,用于创建其外观和行为可由最终用户修改(个性化设置)的网页。每个页的用户定义设置被保存下来以供今后的浏览器会话使用。

    System.Web.Util

    包含使回调方法能够在事务的范围下运行以及允许将工作发送到单独线程的类。

    System.Windows

    提供了一些重要的 Windows Presentation Foundation (WPF) 基元素类、各种支持 WPF 属性系统和事件逻辑的类以及由 WPF 核心和框架更加广泛使用的其他类型。

    System.Windows.Annotations

    包含支持对在 Windows Presentation Foundation (WPF) 文档查看控件中显示的内容添加用户创建的批注的类型。

    System.Windows.Annotations.Storage

    包含用于定义存储结构和介质以保存和检索用户创建的批注的类。

    System.Windows.Automation

    包含提供对 Windows Presentation Foundation (WPF) 用户界面自动化客户端的支持的类。

    System.Windows.Automation.Peers

    定义 AutomationPeer 基类以及从其派生的并对应于 .NET Framework 控件的一组类型。

    System.Windows.Automation.Provider

    包含用于为 Windows Presentation Foundation (WPF) 创建 UI 自动化提供程序的类型。

    System.Windows.Automation.Text

    包含用于指定 Windows Presentation Foundation (WPF) UI 自动化的文本格式设置和相关行为的枚举。

    System.Windows.Controls

    包含用于创建使用户可以与应用程序进行交互的控件的类。

    System.Windows.Controls.Primitives

    包含旨在用作其他更复杂控件的一部分的基类和控件。

    System.Windows.Converters

    包含在 Windows Presentation Foundation (WPF) 中的序列化期间支持类型转换的类。

    System.Windows.Data

    包含用于将属性绑定到数据源、数据源提供程序类以及集合和视图的特定于数据的实现的类。

    System.Windows.Documents

    包含支持创建 FixedDocument、FlowDocument 和 XML 纸张规范 (XPS) 文档的类。

    System.Windows.Documents.DocumentStructures

    提供用于描述 XpsDocument 的结构(包括节、段落、图形、项目符号列表或编号列表以及表格)的类。

    System.Windows.Documents.Serialization

    包含支持创建和使用运行库可访问的插件序列化程序的类,这些序列化程序可读写不同数据格式的文档。

    System.Windows.Forms

    包含用于创建基于 Windows 的应用程序的类,这些应用程序可以充分利用 Windows 操作系统中的丰富用户界面功能。

    System.Windows.Forms.Design

    包含支持 Windows 窗体组件的设计时配置和行为的类。这些类包括:提供 Windows 窗体组件(即一组设计时服务)支持的设计器类、用于配置特定类型的属性的 UITypeEditor 类,以及用于导入 ActiveX 控件的类。

    System.Windows.Forms.Design.Behavior

    包含用于为组件创建设计时的自定义用户界面行为的类。

    System.Windows.Forms.Integration

    包含支持 Windows 窗体与 Windows Presentation Foundation (WPF) 控件之间的交互操作的类。

    System.Windows.Forms.Layout

    包含支持设计时和运行时布局行为的类。

    System.Windows.Forms.VisualStyles

    包含用于通过视觉样式呈现控件和其他 Windows 用户界面元素的类。

    System.Windows.Ink

    System.Windows.Ink.AnalysisCore

    提供墨迹分析的基级功能。

    System.Windows.Input

    包含支持 Windows Presentation Foundation (WPF) 输入系统的类。

    System.Windows.Input.StylusPlugIns

    提供支持对来自 Windows Presentation Foundation (WPF) 平台上 Tablet 笔的数据进行操作的类。

    System.Windows.Interop

    包含支持 Windows Presentation Foundation (WPF) 和其他技术之间的交互操作的类。

    System.Windows.Markup

    包含在 Windows Presentation Foundation (WPF) 应用程序中支持序列化和可扩展应用程序标记语言 (XAML) 的类。

    System.Windows.Markup.Localizer

    包含用于协助进行二进制 XAML (BAML) 源的本地化的类型。

    System.Windows.Markup.Primitives

    包含在 Windows Presentation Foundation (WPF) 应用程序中支持可扩展应用程序标记语言 (XAML) 的类。

    System.Windows.Media

    包含允许在 Windows Presentation Foundation (WPF) 应用程序中集成丰富媒体的类,这些媒体包括绘图、文本和音频/视频内容。

    System.Windows.Media.Animation

    包含用于在 Windows Presentation Foundation (WPF) 应用程序中提供属性动画功能的类。

    System.Windows.Media.Converters

    包含由标记编写器用于序列化可扩展应用程序标记语言 (XAML) 的类型。

    System.Windows.Media.Effects

    包含可用于将视觉效果应用到位图图像的类型。

    System.Windows.Media.Imaging

    包含用于对位图图像进行编码和解码的类型。

    System.Windows.Media.Media3D

    包含在 Windows Presentation Foundation (WPF) 应用程序中支持类型三维表示形式的类。

    System.Windows.Media.Media3D.Converters

    定义 MarkupWriter 类用于序列化可扩展标记语言 (XAML) 的类型。

    System.Windows.Media.TextFormatting

    包含用于控制文本的格式设置的类型,文本格式控制通常是在低于基于控件的文本表示形式或文本对象模型的级别上进行。

    System.Windows.Navigation

    包含用于导航(包括窗口之间的导航)和导航日记的类型。

    System.Windows.Resources

    提供支持 Windows Presentation Foundation (WPF) 资源模型和“资源”生成操作的低级类。

    System.Windows.Shapes

    包含可以在可扩展应用程序标记语言 (XAML) 或代码中使用的形状库。

    System.Windows.Threading

    包含支持 Windows Presentation Foundation (WPF) 线程处理系统的类。

    System.Windows.Xps

    包含用于将 XML 纸张规范 (XPS) 文档写入到数据存储区或打印队列的类。

    System.Windows.Xps.Packaging

    包含可使应用程序读写 XPS 文档组件的类型。

    System.Windows.Xps.Serialization

    包含支持 XPS 文档序列化的类。

    System.Workflow.Activities

    包含用于定义可添加到工作流中以创建和运行工作进程的可执行表示形式的活动的类。

    System.Workflow.Activities.Configuration

    包含表示配置文件的节的类。

    System.Workflow.Activities.Rules

    包含用于定义构成规则的条件和操作的类。

    System.Workflow.Activities.Rules.Design

    包含用于管理“规则集编辑器”和“规则条件编辑器”对话框的类。

    System.Workflow.ComponentModel

    包含用于创建活动和工作流的类型。

    System.Workflow.ComponentModel.Compiler

    提供用于验证和编译活动和工作流的基础结构。

    System.Workflow.ComponentModel.Design

    包含开发人员可用于生成工作流和活动的自定义设计时行为的类。

    System.Workflow.ComponentModel.Serialization

    提供用于管理活动和工作流在可扩展应用程序标记语言 (XAML) 和 CodeDOM 之间的序列化的基础结构。

    System.Workflow.Runtime

    包含可用于控制工作流运行时引擎和工作流实例的执行的类型。

    System.Workflow.Runtime.Configuration

    包含用于配置工作流运行时引擎的类。

    System.Workflow.Runtime.DebugEngine

    包含在调试工作流实例的过程中使用的类型。

    System.Workflow.Runtime.Hosting

    包含与通过宿主应用程序提供给工作流运行时引擎的服务相关的类。

    System.Workflow.Runtime.Tracking

    包含与跟踪服务相关的类型。

    System.Xml

    提供基于标准的 XML 处理支持。

    System.Xml.Linq

    包含用于 LINQ to XML 的类型,LINQ to XML 是内存中的 XML 编程接口,使您可以轻松有效地修改 XML 文档。

    System.Xml.Schema

    包含提供基于标准的 XML 架构定义语言 (XSD) 架构支持的 XML 类。

    System.Xml.Serialization

    包含用于将对象序列化为 XML 格式的文档或流的类。

    System.Xml.Serialization.Advanced

    包含可让您自定义从 Web 服务描述语言 (WSDL) 文档生成的代码的类。

    System.Xml.Serialization.Configuration

    包含用于读取应用程序配置文件中的 system.xml.serialization 元素节中的值的类。

    System.Xml.XPath

    包含用于定义游标模型的类,该模型可将 XML 信息项作为 XQuery 1.0 和 XPath 2.0 数据模型的实例进行导航和编辑。

    System.Xml.Xsl

    提供可扩展样式表转换 (XSLT) 转换支持。此命名空间支持 W3C XSL 转换 (XSLT) 1.0 版建议。

    System.Xml.Xsl.Runtime

    提供对 System.Xml.Xsl 命名空间中的类的内部支持。此命名空间中的类支持 .NET Framework 基础结构,但不应在代码中直接使用。

    UIAutomationClientsideProviders

    包含单个用于映射客户端自动化提供程序的类。

    展开全文
  • 一个软件设计的好坏,我想很大程度上取决于它的整体架构,而这个整体架构其实就是你对整个宏观商业业务的抽象框架,当代表业务逻辑的高层抽象层结构 合理时,你底层的具体实现需要考虑的就仅仅是一些算法和一些具体...
  • 初步认识数据库和数据库的结构抽象,介绍什么是数据库,三大经典数据模型——层次模型、网状模型、关系模型,数据库的三个模式——外模式,概念模式,内模式,以及查缺补漏的习题等。
  • B站最好的的C语言视频教程 思维导图原图,可以看视频领取。 C++重点知识整理 入门小知识 命名空间 概念:命名空间是新定义一个作用域,里面可以放函数,变量,定义类等,主要用来防止命名冲突 实现 ...
  • 视频中的算术运算符 视频算术符号 逻辑符号 视频标准缩写是-------国际标准: CABAC 基于上下文的自适应二进制算术编码 CAVLC 基于上下文的自适应变长编码 CBR 恒定比特率 CPB 编码图像缓存区 DPB ...
  • 视频基础知识汇总

    千次阅读 2018-06-10 12:38:48
    一、视频采集视频采集把模拟视频转换成数字视频,并按数字视频文件的格式保存下来。所谓视频采集就是将模拟摄像机、录像机、LD视盘机、电视机输出的视频信号,通过专用的模拟、数字转换设备,转换为二进制数字信息的...
  • 一口一个设计模式--简单工厂VS工厂VS抽象工厂

    千次阅读 热门讨论 2014-05-16 16:30:43
    工厂模式是简单工厂的升级版,抽象工厂是工厂模式的升级版,简单工厂+抽象工厂是抽象工厂的升级版。知道了它们之间的宏观关系,下面我带它们从一次次蜕变了解它们为什么是这样的关系。
  • 前端人员必看CSS命名规范

    万次阅读 2017-07-25 11:35:49
    所以CSS命名规范 命名是 前端人员必看的。 文章整理了Web前端开发中的各种CSS规范,包括文件规范、注释规范、命名规范、书写规范、测试规范等。 一、文件规范1、文件均归档至约定的目录中。具体要求通过豆瓣的...
  • C++核心精讲视频课程

    2019-03-30 18:37:05
    14__string和vector-命名空间 15__string和vector-string字符串 16__string和vector-vector向量 17__数组和指针-数组 18__数组和指针-指针 19__运算符和表达式-算术运算符 20__运算符和表达式-关系运算与逻辑运算 21...
  • .NET重构(一):抽象工厂模式实现登录

    千次阅读 热门讨论 2014-12-25 19:24:31
    导读:一路艰辛,我也走到了重构。...重构的第一步就是实现登录,考虑到换数据库的问题,就结合了设计模式上的抽象工厂模式。接下来,就说说在这个过程中的一些问题。 文章说明:本文不会贴登录实现的具体
  • 常见视频编码格式解析

    万次阅读 多人点赞 2017-12-15 14:12:56
    常见视频编码格式解析 常见视频编码格式解析 1.MPEG2-TS编码技术 1.1.MPEG-TS简介 1.2.基本概念及TS流概述 1.3.基本流程 1.4.TS流传输包(简称TS包)结构分析 1.4.1.TS包包头 1.4.2.TS包净荷部分 1.5.PS节目流 ...
  • RDD:基于内存的集群计算容错抽象

    千次阅读 2016-01-12 11:57:13
    相比之下,RDD则为基于工作集的应用提供了更为通用的抽象,用户可以对中间结果进行显式的命名和物化,控制其分区,还能执行用户选择的特定操作(而不是在运行时去循环执行一系列MapReduce步骤)。RDD可以用来描述...
  • Name Space (命名空间):在一个特定空间内,某一资源(文件、网页、音乐、图像等)具有全局唯一的标识符URI(名字)。例如,目前的互联网(Internet)就是最大的一个Namespace.  命名的分类:Flat or ...
  • title: 命名实体识别学习-用lstm+crf处理conll03数据集 date: 2020-07-18 16:32:31 tags: 命名实体识别学习-用lstm+crf处理conll03数据集 文章目录命名实体识别学习-用lstm+crf处理conll03数据集一 整合时要解决的...
  • 韦东山嵌入式学习视频完整目录

    千次阅读 2019-02-23 14:02:33
    旧1期,2010年开始录,主要帮朋友推销开发板,没想要进入培训行业,2017年9月,重录第1期裸板视频命名为新1期。 为什么要重录? 因为很多同学反映没有Linux操作经验、没有单片机基础很难看懂旧1期...
  • 有作业,课程,讲义,考试题,答案,视频,源码,方便学习。 每次重头开始看书都是看那些基本语法,语法看得太多并没有任何效果,以后不再复习C的基础知识,比如变量,语句,循环看得再多也还是不会面向对象,以后...
  • 本系列文章分享了基于Agora SDK 2.1实现多人视频通话的实践经验。 在上一篇《Android 多人视频聊天应用的开发(一)一对一聊天》中我们学习了如何使用声网Agora SDK 进行一对一的聊天,本篇主要讨论如何使用 ...
  • 上篇文章说道,我们这套东西暂且命名为u8 sdk,那么我们这个抽象层就叫U8 SDK。为了可以将各个功能作为插件式开发,我们抽象接口的时候,也将各个功能分开。 首先,我们定义两个接口,一个是登陆...
  • J2EE总结:Java命名与目录接口JNDI

    千次阅读 2012-01-02 00:40:29
    JNDI是 Java 命名与目录接口(Java Naming and Directory Interface),在J2EE规范中是重要的规范之一,不少专家认为,没有透彻理解JNDI的意义和作用,就没有真正掌握J2EE特别是EJB的知识。 那么,JNDI到底起什么...
  • 视频处理是人工智能应用中的一个重要方向,对于一款端上部署的AI加速产品,其视频接入能力是产品技术实力的重要体现,同时也直接影响用户的产品体验。端上的嵌入式设备,受制于本身的CPU等硬件资源,同时支持多种...
  • K8S基本概念视频教学学习笔记

    千次阅读 2017-09-25 13:13:58
    K8S基本概念-视频教学-学习笔记     Rancher官方免费培训视频网址: 视频网址:http://v.youku.com/v_show/id_XMjg5MTM5MjMxNg 视频时长:56分钟   目录: 1、配置Rancher和Kubernetes 2、K8S CLI: ...
  • Lxr-《Hb》2015.02.19-03.03 ...虽然依本人功力还不能将计算机的物理实体及抽象层次结构笔记到清楚层次,但还是笔记一下。 1.1 二进制系统 规定(注意这个词)只有0和1两个元素(注意这一点),再
  • 软工视频学习笔记——01

    热门讨论 2018-01-14 20:25:23
    开始软工视频学习后,我把学习的天数命名为学习的章数 内容 1.什么是软件 软件是计算机系统中与硬件相互依存的另一部分,它是包括程序,数据及其相关文档的完整集合 2.程序是事先设计的指令序列 3....
  • 7.命名规范(★★★★) a)类的方法与属性、变量通常小写开头,后面单词首字母大写 b)final 常量名通常大写,多个单词中用下划线连接 8.抽象类 a)可以有构造函数 b)不能与关键字private,static,final共存...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,385
精华内容 8,954
关键字:

抽象视频命名