通达信c+接口-javase整合笔记加上自己理解

回顾==的使用:==：运算符

继承性的好处:诚少了代码的冗余，提高了代码的复用性便于功能的扩展为之后多态性的使用，提供了前提继承性的格式:classAextendsB{}；A可以称为:子类、派生类、subclassB可以称为:父类、超类、基类、superclass

可变个数形参的格式，数据类型…变量名

可以被static修饰可以被4种权限符修饰内部类中可以定义属性和方法可以被final修饰可以被abstract修饰

2在类的构造器中，我们可以使用“this.属性“或"this.方祛“的方式，调用当前正在创建的对象属性，通常情况下，我们都选择省略"this."。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显式的使用“this.变量“的方式，表明此变量是属性，而非形参。

全局常量：publicstaticfina1的.但是书写时，可以省略不写抽象方法:publicabstract的2JDK除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法

java面向对象-toString关键字

Object类中的功能就具有通用性。object属性:无方法:equha1s/getclass/hashCode）/clonewait、notify、notifyA11等

异常处理一try-catch-finally;用try将可能发生异常的区域包住，然后用catch解决发生对应的异常的方式，再解决了之后跳出catch，最后执行finally书写格式举例；

构造器的作用。创建对象

javase整合笔记加上自己理解

单例的第二种实现

常见的异常；NullPointerException-空指针引用异常ClassCastException-类型强制转换异常IllegalArgumentException-传递非法参数异常ArithmeticException-算术运算异常ArrayStoreException-向数组中存放与声明类型不兼容对象异常IndexOutOfBoundsException-下标越界异常NegativeArraySizeException-创建一个大小为负数的数组错误异常NumberFormatException-数字格式异常SecurityException-安全异常UnsupportedOperationException-不支持的操作异常NegativeArrayException-数组负下标异常EOFException-文件已结束异常FileNotFoundException-文件未找到异常SQLException-操作数据库异常IOException-输入输出异常NoSuchMethodException-方法未找到异常java.lang.AbstractMethodError-抽象方法错误。当应用试调用抽象方法时抛出。java.lang.AssertionError-断言错。用来指示一个断言失败的错误。java.lang.ClassCircularityError-类循环依赖错误。在初始化一个类时，若检测到类之间循环依赖则抛出该异常。java.lang.ClassFormatError-类格式错误。当Java虚拟机试从一个文件中读取Java类，而检测到该文件的内容不符合类的有效格式时输出。

Java面向对象-面向对象的理解

线程安全问题；当不同的线程操作同一个数据时很容易出现线程安全问题，比如买票问题。

说明:1关于权限修饰符:默认方法的权限修饰符先都使用publicJava规定的4种权限修饰符:private、public、缺省、protected例；

相应的我们自定义的方法也可以重写toString这个方法并且在编译器中有快捷键设置

特殊情况厂当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用"super.方法”的方式，表明调用的是父类中被重写的方法

可以使用在基本数据类型变量和引用数据类型变量中.如果比较的是基本数据类型变量:比较两个变量保存的数据是否相等，如果比较的是引用数据类型变量:比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体

封装性的体现，需要权限修饰符来配合。Java规定的4种权限（从小到大排列):private、缺省、protected、public

如何定义接口:定义接口中的成员1JDK7及以前:只能定义全局常量和抽象方法

如果ainstanceofA返true,则ainstanceofB也返回true其中，类B是类A的父类

start;启动当前线程；调用当前线程的run方法。run;重写Thread中的此方法，将创建的线程执行的操作声明在此方法中3,currentThread;静态方法，返回执行当前代码的线程4,getName;得到当前线程的名字5,setName;设置当前线程的名字6,yield;释放当前cpu的执行权7,join;在线程a中调用线程b的join，此时线程a就进入阻塞状态，只当线程b执行完全以后，线程a才结束阻塞状态。9,sleep;让当前的线程进入睡眠，在指定的毫秒之后结束睡眠10,isAlive;判断线程是否存活

特殊情况:当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用“super.属性“的方式，表明调用的是父类中声明的属性。

理解多态性：可以理解为一个事物的多种形态。

2我们定义方法该不该有返回值?题目要求凭经验:具体问题具体分析

用throws抛的异常没有将其实际的解决，是抛给了需要用到此方法的上一级，最后上一级再用try-catch来解决thorws抛出的异常

把冰箱门打开

Java中，接口和类是并列的两个结构

的地方称为堆）如上，因为p1和p2都是指向0x12ab所以当改变p2中的值相应的p1的值也会改变。

注；Stringgetmessage；获得String行错误信息printstacktrace;在控制台打印出异常种类，错误信息和出错位置等在没有finally的情况下，当try抓住异常之后就会进入相应的catch进行异常处理，一旦完成则会跳出try-catch结构然后继续跑后面的代码。-----在catch中的异常类型没子父类关系时，谁声明在上无所谓-----在catch中的异常类型存在子父类关系时，子类必须声明在上面否则报错在try中声明的变量在跳出异常时不能被调用

举例，编译0到100的奇数并求得他们的和

>public class FutureTask_Test {
    public static void main(String[] args) {
        //3，造一个实现了callable实现类的对象
        SumTest sumTest = new SumTest();
        //4，造一个FutureTask对象并将实现类callable的对象当成参数传进构造器
        FutureTask<Integer> futureTask = new FutureTask(sumTest);
        //5，造一个Thread类的对象并将实现了FutureTask类的对象当成参数传入Thread的构造器
        Thread thread = new Thread(futureTask);
        //6，调用Thread中的start方法
        thread.start();
        try {
            //如果需要返回的参数就使用FutureTask中的get方法
            Integer o = futureTask.get();
            System.out.println(o);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
//1，实现callable接口
class SumTest implements Callable<Integer> {
    int i = 0;
    int sum = 0;
    @Override
    //2，重写call方法
    public Integer call() throws Exception {
        for(i = 0; i <= 100; i++){
            if(i % 2 == 1){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}

java面向对象-方法的重写

4种权限可以用来修饰类及类的内部结构:属性、方法、构造器、内部类具休的，4种权限都可以用来修饰类的内部结构:属性、方法、构造器、内部类修饰类的话，只能使用，缺省、public

构造器中不能通过"this“方式调用自己

如何才能调用子类特有的属性和方法?向下转型:使用强制类型转换符。

1final修饰属性：可以考虑赋值的位置有：显式初始化、代码块中初始化、构造器中初始化2fina1修饰局部变量:尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参一个实参，一旦使用以后，就只能在方法体内使用此形参，但不能进行重新赋值。

方式3实现callable接口

多态性的使用前提:

比如当三个线程同时卖50张票。

>public class SynchronizedTest {
    public static void main(String[] args) {
        method1 m = new method1();
        Thread t1 = new Thread(m);
        Thread t2 = new Thread(m);
        Thread t3 = new Thread(m);
		 t1.setName("一号窗口");
        t2.setName("二号窗口");
        t3.setName("三号窗口");
		 t1.start();
        t2.start();
        t3.start();
    }
}
class method1 implements Runnable{
    private int ticket = 0;
    @Override
    public void run() {
        while(true) {
            if (ticket <= 50) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "； 获得" + ticket + "号票");
                ticket++;
            } else {
                break;
            }
        }
    }
}

并行与并发

1如果方法有返回值，则必须在方法声明时，指定返回值的类型。方法中，需要使用return关键字来返回指定类型的变量或常量：“return数据”。如果方法没有返回值，则方法声明时，使用void来表示。没有返回值的方法中，就使用return.如果使用的话，只能“return;"表示结束此方法的意思。

3方法名:属于标识符，谨循标识符的规则和规范，“见名知意”

方式创建多线程实现Runnable接口

abstract不能用来修饰:属性、构造器等结构abstract不能用来修饰私有方法、静态方法、final的方法、final的类

方法；描述应具有的功能举例publicvoideat{}publicvoidsleep{}publicStringgetName{}publicStringgetNation{}方法的声明:权限修饰符返回值类型方法名(形参列表）{方法体｝例；

像string、Date、Fi1e、包装类等都重写了0bject类中的equals方法，重写以后，比较的不是两个引用的地址是否相同，而是比较两个对象的“实体内容“是否相

按是否使用static修饰，又分为:静态属性vS非静态属性实例变量；我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改。

二号窗口；获得0号票三号窗口；获得0号票一号窗口；获得0号票二号窗口；获得3号票一号窗口；获得3号票三号窗口；获得3号票二号窗口；获得6号票一号窗口；获得6号票三号窗口；获得6号票三号窗口；获得9号票一号窗口；获得9号票二号窗口；获得9号票三号窗口；获得12号票一号窗口；获得12号票二号窗口；获得12号票一号窗口；获得15号票三号窗口；获得15号票二号窗口；获得15号票二号窗口；获得18号票一号窗口；获得18号票三号窗口；获得20号票一号窗口；获得21号票三号窗口；获得21号票二号窗口；获得21号票三号窗口；获得24号票二号窗口；获得25号票一号窗口；获得26号票一号窗口；获得27号票二号窗口；获得27号票三

父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类父类被重写的方法的返回值类型是基本数据类型，要么都声明为static的（不是重写)方法抛出的异常类型不大于父类被重写的方法抛出的异常类型

javase整合笔记加上自己理解

如果一个类中有n个构造器，则最多有n-1构造器中使用了"this“规定:“this”必须声明在当前构造器的首行

java面向对象-多态的理解与使用

封装性的体现，我们将类的属性私有化提供公共的万法来获取和设置来限制//用年龄限制比如-10岁就用set对年龄限制并且将年龄设置private

finally的使用，finally是可以选择性使用的finally中是声明一定会被执行的代码，即时出现了异常并且被catch处理了也会继续执行finnaly中的代码

public class Mathead {
        public static void main(String[] args) {
            Mathead m = new Mathead();
            System.out.println(m.test());
        }
        public int test(){
            try {
                int a = 0;
                int b = 1;
                System.out.println(b/a);
            }
            catch(ArithmeticException e ){
                e.printStackTrace();
                return 1;
            }
            finally {
                System.out.println("finally必须被执行");
            }
            return 2;
        }
}

fina1可以用来修饰的结构:类、方法、变量fina1用来修饰一个类:此类不能被其他类所继承。

4形参列表:方法可以声明0个，1个，或多个形参。1格式:数据类型1形参数据类型2开参…例；

java面向对象-static关键字

静态变量:；我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。注；静态属性非静态属性类可以调用不可以调用对象可以调用可以调用

单核cpu和多核cpu的理解

静态方法随着类的加载而加载，可以通过“类.静态方法”的方式进行调用类

接口，实际上可以看做是一种规范

方式使用线程池

多态的定义与使用格式；父类类型=new子类类型；

import关键字和使用import:导入在源文件中显式的使用import结构导入指定包下的类、接口声明在包的声明和类的声明之间

java面向对象-继承

接口的使用按口使用interface来定义

私有化类的构造器内部创建类的对象,要求此对象也必须声明为静态的提供公共的静态的方法，返回类的对象

java面向对象-四种权限以及getter和setter

使用static修饰方法:

2返回值类型，有返回值VS没有返回值

java面向对象-构造器

创建一个继承于Thread类的子类重写Thread类的run，将现场需要实现的方法体卸载run方法中主函数中创建Thread类的子类对象通过此对象调用start方法start方法会启用当前线程并且调用当前线程的run方法

>public class ThreadTest extends Thread{
    @Override
    public void run() {
       for(int i = 0; i < 100;i++){
           if(i % 2 == 1){
               //遍历100以内的单数并且打该线程的名字
               System.out.println(Thread.currentThread().getName()+" "+i);
           }
       }
    }
 public static void main(String[] args) {
        ThreadTest tt1 = new ThreadTest();
        tt1.start();
    }
}

定义构造器的格式：权限修饰符类名{}

线程池中提供的APIExecuttorService；线程池接口，常见的子类有ThreadPoolExecutorExecutors；工具类，用于创建并返回不同类型的线程池``Executors.newFixedThreadPool;创建一个固定线程数量的线程池

一java中是可以在一个类A中声明其他类B的。此时A称作外部类，B称作内部类。

引用数据类型（类、数组、接口):null局部变量:没有默认初始化值。意味着，我们在调用局部变量之前，一定要显式赋值。特别地:形参在调用时，我们赋值即可。4在内存中加载的位置:属性:加载到堆空间中局部变量:加载到栈空间注；栈中的数据是存在生命周期的，而堆中的数据的生命周期是不一定的成员变量存储在其所属的对象里面，如果是引用的对象存放在栈中，那么对象的成员变量自然也在栈中，如果说对象是new出来的，对象存储在堆中，那么对象的成员变量也在堆中。

关键字:static

java面向对象-单例的两种写法

类的继承关系方法的重写

java面向对象-类和方法

何为多态性？对象的多态性，父类的引用指向子类的对象

1,创建一个类型的线程池将实现了Runnable接口的实现类的对象传入execute方法中3,关闭线程池

public class ThreadPoolExecutorTest {
    public static void main(String[] args) {
        pooltest p = new pooltest();
        //1,创建一个类型的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        //2，将实现了Runnable接口的实现类的对象传入execute方法中
        service1.execute(p);
//        service1.submit();//使用实现了callable接口的类
        //3，关闭线程池
        service1.shutdown();
    }
}
class pooltest implements Runnable{
    int i = 0;
    @Override
    public void run() {
        for (i = 0; i <= 100; i++) {
            if (i % 2 == 1) {
                System.out.println(i);
            }
        }
    }
}

2我们定义方法时，该不该定义形参?题目要求凭经验，具体问题真飞分析

abstract使用上的注意点:

判断是否是重载:跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系!在通过对象调用方法时，如何确定某一个指定的方法：方法名—>参数列表

java面向对象-接口

用throws来处理异常

static注意点:

java.1ang.Object类Object类是所有Java类的根父类如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.0bject类

this调用构造器我们在类的构造器中，可以使用“this“方式，调用本类中指定的其他构造器

多态的使用:虚拟方法调用有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方总结:编译，看左边，运行，看右边。

java面向对象-内部类

java面向对象-import关键字

在JDK8中除了定义全局变量和抽象方法之外还可以定义静态方法和默认方法；

java面向对象-对象的内存解析

面向对象的特征一:封装与隐藏

当我们创建一个类的对象以后，我们可以通过"对象.属性”的方式，对对象的属性进行赋值。这里，赋值操作要受.属性的效据类型和存储范围的制约。除此之外，投有其他制约条件。但是，在实际间题中，我们往往需要给属性赋加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的活加。 同时，我们需要避免用户再使用”对象.属性”的方式对属性进行赋值。则需要将属性声明为私有的(private)

final用来修饰方法:表明此方法不可以被重写比如:Object类中getClass;.final用来修饰变量:此时的“变量”就称为是一个常量

再看一种以后常用的多态赋值形式

什么是类？什么是对象？我们可以将类比作汽车的设计纸它是一个抽象的东西，而对象则是根据这个纸创造出来的汽车，他是实实在在的存在如何设计一个类呢？就像是造汽车一样我们也需要根据汽车的各个地方结构的不同造不同的设计也就是说类的设计就是类中的成员的设计也就是说面向对象有两个要素类；对一类事物的定义是概念的定义对象；是实际存在的每一个个体，也可以叫做实例例；我们可以造一个Person类和PersonText1类。classperson就是我们定义的纸，其中有我们给这个人的属性和方法而这些属性和方法在主函数中的使用也在中了，主要语法就是对象名.方法/属性

单核cpu，其实是一种假的多线程，因为在一个单元时间内，也只能执行一个线程的任务。如果时多核的话，才能更好的发挥多线程的效率一个java应用程序java.exe，至少又三个线程；main主线程，gc垃圾回收线程，异常处理线程。

格式；“throws+异常类型”写在方法的后面，表明当此方法执行时可能会抛出某个异常。当方法被执行时，此对象满足抛出的异常类型就会被抛出。并且不再执行异常代码之后的代码

public class TrowsTest {
    //创建一个对象并且将异常抛出
    public void methond() throws IOException {
        File f = new File("src//file.txt");
        FileInputStream fis = new FileInputStream(f);
        byte []buffer = new byte[2];
        int len = fis.read(buffer);
        while(len != -1){
            String str = new String(buffer,0,len);
            System.out.print(str);
            len = fis.read(buffer);
        }
        fis.close();
    }
   public static void main(String[] args) {
        TrowsTest t = new TrowsTest();
        //因为调用了methond所以要处理methond抛出的异常
        try {
            t.methond();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    }

如果使用的类或接口是java.lang包下定义的，则可以省略import结构如果使用的类或接口是本包下定义的，则可以省略import结构如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示。注；使用“xxx.*“方式表明可以调用XXX包下的所有结构。但是如果使用的是xXx子包下的结构，则仍需要显示包名导入。importstatic:导入指定类或接口中的静态结构:属性或方法。

java面向对象-this的使用细节

首先我们创造一个人并且创造出这个人的一些功能，然后创造出这个大象和冰箱并将他们的功能给实现。

说明:如果没有显式的定义的构造器的话则系统会默认送给你一个无参数的构造器

接口的具体使用，体现多态性

java面向对象-“==”与equals的区别

创建一个类并且实现Runnable接口重写run方法实例化实现Runnable接口的类创建Thread类的对象并且将实例化的类的对象当作形参传入Thread的对象中通过Thread的对象调用start方法

>public class RunnableTest {
    public static void main(String[] args) {
        Test1 t1 = new Test1();//创建继承Runnable对象
        Thread t = new Thread(t1);// 将t1传入t
        t.start();
    }
}
class Test1 implements Runnable{
    @Override
    public void run() {
        for(int i = 0;i < 100; i++){
            if(i % 2 == 1){
                System.out.println(Thread.currentThread().getName()+" "+i);
            }
        }
    }
}

4可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不共存

–>此时，针对于属性就体现了封装性。

如果我们想在子类中使用父类的方法或者属性可以考虑使用super关键字。

java面向对象-super关键字

public class TrowsTest {
    //创建一个对象并且将异常抛出
    public void methond() throws IOException {
        File f = new File("src//file.txt");
        FileInputStream fis = new FileInputStream(f);
        byte []buffer = new byte[2];
        int len = fis.read(buffer);
        while(len != -1){
            String str = new String(buffer,0,len);
            System.out.print(str);
            len = fis.read(buffer);
        }
        fis.close();
    }
   public static void main(String[] args) {
        TrowsTest t = new TrowsTest();
        //因为调用了methond所以要处理methond抛出的异常
        try {
            t.methond();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    }

一个类中至少有一个构造器

这是在实现类中调用接口中与父类同名同参数的方法如果这个类实现了多个接口，这多个接口之中同时存在同名同参数的方法且这个类中没有对此方法进行重写，那么会报错在子类中调用接口中的方法

包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的若子类重写了父类中的所有的抽象方法后，此子类方可实例化若子类没有重写父类中的所有的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰

java面向对象-可变形参

所有的异常都有一个超类Throwable。它有两个重要的子类Error和ExceptionError；:表示代码运行时JVM出现的问题。是程序无法处理的错误，运行应用程序中较严重问题。如资源耗尽，栈溢出等问题Exception；是程序本身可以处理的异常。可以使用针对性的代码处理的问题。Exception又分为两大类；运行时异常；程序在运行时的异常，编译时不报错运行时报错编译时异常；程序在编译期间就出现的异常，如果不解决程序不会运行

面向对象的三大特征

    >封装（Encapsulation）

    >继承（Inheritance）

    >多态（Polymorphism）

==和equals区别

java面向对象-变量的赋值

对象静态方法中，只能调用静态的方法或属性非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性

java面向对象-属性与局部变量

5可变个数形参在方法的形参中，必须声明在末尾6可变个数形参在方法的形参中，最多只能声明一个可变形参。

子类继承父类以后，还可以声明自己特有的属性或方法:实现功能的拓展。子类和父类的关系，不同于子集和集合的关系。

java-线程安全问题

面向对象与面向过程>二者都是一种思想，面向对象是相对于面向过程而言的。面向过程强调的是做一件事事的行为，考虑的是怎么做。面向对象是将一件事中的每一个对象进行封装然后以对象为最小单位，考虑谁来做

    >面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象，分类，继承，多态等。

Thread中的常用方法

finally在运用与IO流的例子

public class Mathead {
    public static void main(String[] args) {
        //将f指向file.txt这个文件
        File f = new File("src//file.txt");
        //创建字节流
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(f);
            //一次读两个字符
            byte[] buffer = new byte[2];
            //fis.read()方法是读取数组如果读到最后没有东西了返回一个-1
            int len = fis.read(buffer);
            //打印file.txt中的内容
            while (len != -1) {
                String s = new String(buffer, 0, len);
                System.out.print(s);
                len = fis.read(buffer);
            }
        } catch (IOException e){
            e.printStackTrace();
        }
        finally {
            if(fis != null){
                try{
                    fis.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
        }
  }
}

2当调用可变个数形参的方法时，传入的纱数个数可以是0个1个,2个…

Object类只声明了一个空参的构造器

不同点:1在类中声明的位置的不同属性:直接定义在类的{}内局部变量:声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量

我们知道有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致编译时，只能调用父类中声明的属性和方法，子类特有的属性和方法不能调用。

java面向对象-方法

若一个进程同一时间并行多个线程，就是支持多线程的线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器，线程切换的开销小一个进程中的多个线程共享相同的内存单元/内存地址空间，可以访问相同的变量和对象。这就使得线程间通信更简便，高效。但多个线程操作共享的系统资源可能会带来安全隐患

继承的体现:一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有的属性和方法。

类中属性的使用属性与局部变量相同点:1定义变量的格式:数据类型变量名=变量值2先声明，后使用3变量都有其对应的作用域

异常：在java中如果程序运行时出现非正常的情况下会出现异常比如文件查找不存在等问题

1,创建一个实现callable的实现类实现call方法，将想实现的功能写在call方法内创建实现了callable类的对象将实现类callable的对象当作参数传入FutureTask构造器中，创建FutureTask的对象将FutureTask的对象当作参数传入到Thread中并且调用start方法用FutureTask中的get方法得到返回值；返回值为callable中call方法的返回值

如果实现类覆盖了接口中的所有抽象方法，则此文现类就可以实例化如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类

java-多线程的创建方式

java面向对象-向下转型与instanceof

abstract关链字的使用abstract：抽象的abstract可以用来修饰的结构:类、方法。

面试题:区分方法的重载与重写

三如何实例化成员内部类

java面向对象-抽象

并行；多个cpu同时执行多个任务。并发；一个cpu“同时”执行一个任务

二因为是在类中创建的类，所以内部类既有成员的性质也有类的性质

此类不能实例化

拓展:封装性的体现:如上·不对外最露的私有的方法单例横式

super理解为:父类的super可以用来调用:属性、方法、构造器super的使用我们可以在子类的方法或构造器中。通过使用"super.属性"或“super.方法”的方式，显式的调用父类中声明的属性或方法。通常情况下，我们习惯省略"super.”

abstract修饰方法:抽象方法

java面向对象-object类

super调用构造器我们可以在子类的构造器中显式的使用"super”的方式，调用父类中声明的指定的构造器

当我们输出一个对象的引用时，实际上就是调用当前对象的toStringObject类中toString的定义:

public String toString() { 
return getClass()·getName ()+"@"+Integer.toHexString(hashCode)) ;
}

单例设计横式，1:所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，如何实现?

equals方法的使用，是个方法，而非运算符只能适用于引用数据类型Object类中equa1s的定义，publicbooleanequals{return;｝说明.Objec类中定义的equals和==的作用是相同的，比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体

3可变个数形参的方法与本类中方法名相同，形参个数不同的方法之间构成重载

使用强转时，可出现ClasscastExceptiont异常那我们如何判断两个对象之间是否相互实现呢？ainstanceofA:判断对象a是否是类A的实例。如果是。返ture,如果不是，返回false.使用情境；为了避免有向下特型时出现ClasscastException的异常，我们在向下转型之前，先进行instanceof的判断一旦返回true.就进行向下转型。如果返回false.不进行向下转型

java面向对象-final关键字

构造器内部，最多只能声明一个“this“，用来调用其他的构造器

Java类可以实现多个接口—>弥补了Java单继承性的局限性格式:classAAextendsBBimplementsCC,DD,EE

抽象类中一定有构造器，便于子类实例化时调用开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作

java面向对象-方法的重载

在jdk7之前局部内部类中的方法如果需要用到局部内部类声明方法中的局部变量的话，要求此变量需要声明为final，jdk8之后默认声明为final。

根据上一章中类与对象的基础上我们再创建一个Personp2p2=p1之后改变p2中的值再运行

将冰箱门关闭

callable是jdk0新增的callable可以有返回值Runnable没有callable支持泛型callable可以抛异常

“super“的使用，必须声明在子类构造器的首行!我们在类的构造器中，针对于“this”“或“super“只能二选不能同时出现在构造器的首行，没有显式的声明“this“或"super，则默认调用的是父类中空参的构造

abstract修饰类:抽象类

当内部类是静态成员内部类时当内部类是非静态成员内部类时四如何在成员内部类调用外部类的结构

接口与接口之间可以继承，而且可以多继承

在开发的过程中我们优先选择Runnable接口Runnable接口没有单继承的局限性Runnable更使用与存在共享数据的情况线程池能放入实现Runable或callable类线程，但是不能直接放入继承Thread的类

方法的重写重写:子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作

将大象放进冰箱

重写的规定:

当一个类的内部还需要液体个完整的结构进行描述，而这个内部的完整结构又只为外部提供服务，那么这整个内部的完整结构最好使用内部类

方式创建多线程继承Thread类

进程；在网络上的操作都是实时进程，例如你打开的网页、游戏、统称实时进程。线程；是进程的一个执行路径，一个进程中至少有一个线程，进程中的多个线程共享进程的资源。

一个类中定义了多个构造器彼此称为重载如果定义了类的构造器之后，系统就不会提供默认的无参数构造器了

如果实现类中的父类有接口中的同名同参数方法，那么子类在调用的时候运行的是父类中的方法。

如果需要导入多个结构，则并列写出即可可以使用“xxx.*“的方式，表示可以导入xxx包下的所有结构

关于变量的赋值:如果变量是基本数据类型，此时赋值的是变量所保存的数据值。如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

像String、Date、File、包装类等都重写了0bject类中的toString方法。

在接口中定义为静态方法不可以用实现类调用，在接口中的方法只能用接口来调用

定义，在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。“两同一不同“:同一个类、相同方法名参数列表不同：梦数个数不同，参数类型不同，举例:Arrays类中重载的sort（)/binarysearch)

用throws来处理异常

java面向对象-this关键字

static:静态的static可以用来修饰:属性、方法、代码块、内部类使用static修饰属性:静态变量

如何将大象装进冰箱

this关健字的伊用，this可以用来修饰，属性、方法、构造器this修饰属性和方法，this理解为当前对象或当前的正在创建的对象的什么东西在类的方法中，我们可以使用“this.属性“或“this.方法“的方式，调用当前对象属性或方法。但是通常情优下，我们都选择省略“this."。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用“this.变量”的方式，表明此变量是属性，而非形参。

异常：在java中如果程序运行时出现非正常的情况下会出现异常比如文件查找不存在等问题

用throws抛的异常没有将其实际的解决，是抛给了需要用到此方法的上一级，最后上一级再用try-catch来解决thorws抛出的异常

两种方式的比较

约定:子类中的叫重写的方法，父类中的叫被重写的方法子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符>特殊情况：子类不能重写父类中声明为private权限的方法返回值类型:

finally在运用与IO流的例子

public class Mathead {
    public static void main(String[] args) {
        //将f指向file.txt这个文件
        File f = new File("src//file.txt");
        //创建字节流
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(f);
            //一次读两个字符
            byte[] buffer = new byte[2];
            //fis.read()方法是读取数组如果读到最后没有东西了返回一个-1
            int len = fis.read(buffer);
            //打印file.txt中的内容
            while (len != -1) {
                String s = new String(buffer, 0, len);
                System.out.print(s);
                len = fis.read(buffer);
            }
        } catch (IOException e){
            e.printStackTrace();
        }
        finally {
            if(fis != null){
                try{
                    fis.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
        }
  }
}

面向对象特征之多态性

这里举一个例子；

Java开发中，接口通过让类去实现的方式来使用。

finally的使用，finally是可以选择性使用的finally中是声明一定会被执行的代码，即时出现了异常并且被catch处理了也会继续执行finnaly中的代码

public class Mathead {
        public static void main(String[] args) {
            Mathead m = new Mathead();
            System.out.println(m.test());
        }
        public int test(){
            try {
                int a = 0;
                int b = 1;
                System.out.println(b/a);
            }
            catch(ArithmeticException e ){
                e.printStackTrace();
                return 1;
            }
            finally {
                System.out.println("finally必须被执行");
            }
            return 2;
        }
}

特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。只有因为封装性的影响，使得子类不能直接调用父类的结构而已。被private修饰的属性或方法不能直接调用，但是可以间接的调用比如private属性用和调用

2关于权限修饰符的不同属性:可以在声明属性时，指明其权限，使用权限修饰符。常用的权限修饰符:private、public、缺省、protected目前，大家产明属性时，都使用缺省就可以了。局带变量，不可以使用权限修饰符。

2.3默认初始化值的情况: 属性:类的属性，根据其类型，都有默认初始化值。
 整型(byte、 short、 int、 10ng): 0
  浮点型（f10at、 double):0.0
   字符型（chan):日（或"uO000") 布尔型(boolean): false

接口中不能定义构造器的！意味着接口不可以实例化

在类的多个构造器中，至少有一个类的构造器中使了“super”，调用父类中的构造器

在静态的方法内，不能使用this关键字、super关键字关于静态属性和静态方法的使用，大家都从生命周期的角度去理解。

如果接口中定义了默认方法，则可以通过类来调用。注；如果实现类重写了接口中默认的方法，则调用的时候用的时重写的方法。

应用:重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法

抽象方法只有方法的声明，没有方法体

文章为作者独立观点，不代表股票交易接口观点

通达信c+接口-第七章 输入输出接口_绀香零八的博客_输入输出接口

通达信c+接口-第七章输入输出接口_绀香零八的博客_输入输出接口