面向对象：一直都是很混乱的东西，原来这简简单单的“面向对象”里竟有如此深的含义。我例举一下：1.它是一种编程方法2.他是一种思维方式3.切记切记，它不是编程语言，是以上两种。面向对象不简单，听完mars的讲解更好的理解了，他是一种方法，就像c语言编程方法是面向过程，倒置他们的思维方式也有不同，但这些不是编程的语言，一切围绕面向对象的思维方式，否则或许编写出来编程面向过程了。如何学习面向对象：1.掌握面向对象的语法2.掌握面向对象的思维方式3.掌握面向对象的设计原则4.掌握面向对象设计模式最重要的是面向对象的思维方式！终极目标是消除重复代码。如何消除，就要遵守面向对象的设计原则（很多），如何遵守，去看去学习已有设计模式，更加便捷，一环扣一环。最重要的思维方式如何学：1.谁来做，怎么做。2.先考虑整体，在考虑局部。3.先考虑抽象，在考虑具体。（其实很像现实生活，方方面面都有这种思维方式的技巧。看看视屏吧，我或许讲解不清楚！）

大学老师讲的不懂，mars老师很厉害，基础原理现在弄的很清楚了，豁然开朗啊。其实这就是java基础教程了。首先是环境变量，他是有path和classpath组成。path是外部搜索路径，其实就是在是使用命令程序的路径，运行的程序在哪里，路径也就在哪里了。    classpath是类文件搜索路径，也就是当前文件路径，是以“.”表示。jre就是java running environment，java运行环境，比如你睡觉在卧室，它提供了船和被子；做饭在厨房，它提供了厨具和食材；java运行环境提供了java运行的条件。jvm是java virtual machine 简称java虚拟机。软件运行在虚拟机，虚拟机是给不同操作系统提供编译。所以说编写一次，处处运行就是这个道理了。

ACSII字符集Unicode字符集一个是二进制数，一个是十六进制数；一个是固定编码，一个是语言转换编码；都是互相转换人类和计算机所识别的语言。也知道乱码的原因了，但这怎么去改正？自己百度一下。

为什么要使用抽象类：1、在抽象类中的抽象函数是必须调用的，可以调用、复写。当子类忘记调用和复写时编译是会出现问题。（它可以将错误直接提醒，强制在子类上复写父类的函数体。）2、上面只是其中一种，欲知后事如何，请续看教学。注：如果一段代码在语意上是有错误的，那么在语法上也应该是有错误的。

大文件的读写方法：定义好字节行java程序并输入，利用循环部分部分读取，最后输出字节。（大文件是不可能一次性读取完的，记住这点。）import java.io.*;class Test{ public static void main(String arge[]){ FileInputStream fis = null; FileOutputStream fos = null; try{ //生成输入输出的对象 fis = new FileInputStream("e:/work/android/src/from.txt"); fos = new FileOutputStream("e:/work/android/src/to.txt"); //定义一个java程序:buffer byte [] buffer = new byte[1024]; //读取字符的循环,在无法读取时,得到值为-1. while (true){ int temp = fis.read(buffer,0,buffer.length); if(temp == -1){ break; } fos.write (buffer,0,temp); } } catch (Exception e){ System.out.println(e); } //关闭io流，撤掉占用的管道,只有做到这点才是比较完整的操作。 finally{ //因为close编译是会报错,所以要用try,catch结构 try{ fis.close(); fos.close(); } catch(Exception e){ System.out.println(e); } } }}字符流的使用方法：其实和字节的输入输出流很相像，就是byte类型变为char类型//字符流：读写文件时以字符为基础//字节输入流 <-- reader的子类 <-- FileReader父类//字符输入流：int read (char [] c, int off, int len);//字节输出流 <-- writer的子类 <-- FileWriter父类//字符输出流：int write(char [] c, int off, int len);import java.io.*;class TestChar{ public static void main(String arge[]){ FileReader fr = null; FileWriter fw = null; try{ fr = new FileReader("e:/work/android/src/from.txt"); fw = new FileWriter("e:/work/android/src/to.txt"); char [] buffer = new char[100]; int temp = fr.read(buffer,0,buffer.length); fw.write(buffer,0,temp); } catch(Exception e){ System.out.println(e); } finally{ try{ fr.close(); fw.close(); } catch(Exception e){ System.out.println(e); } } }}

this代表我，可以是第三方第二方的“我”1.this通常省略，用于调用成员变量和成员函数，当构造函数里的参数与成员变量同名时即可输入this来制定成员变量的使用。eg:String name();void talk(String name){  System.out.println("my name is " + this.name) //此处this是指成员变量的name,而不是参数name.}2.为了不使构造函数使用的混乱，在参数上会于成员变量重名，这时候需要用this.成员变量 = 构造函数的参数；意思是：将参数的值赋值于成员变量。eg:class Person{ String name; int age; String address; Person(){ Sytem.out.println("无参的构造函数"); } Person(String name,int age,String address){ this.name = name;//后面参数“name”赋值给了前者成员变量 this.age = age; this.address = address; }this(); //可在自己的构造函数里调用本类其他的构造函数,根据传入参数的个数和类型来决定调用本类的某个函数。eg:class Person{ String name; int age; String address; Person(){ System.out.println("无参的构造函数"); } Person(String name,int age){ this();//此处是调用上面无参的构造函数，下面调用时也会同时调用上方的构造函数，避免了第二次调用失败。 this.name = name; this.age = age; System.out.println("两个参数的构造函数"); }Person(String name,int age,String address){ this(name,age);//调用上面构造函数的代码，避免重复，必须放第一条 this.address = address; System.out.println("三个参数的构造函数"); }}注：可以调用其他的构造函数，只要在“（）” 里输入参数的个数和类型来决定调用本类的某个函数。也必须是第一个语句（多个呢？）；可在上一个构造函数里再次使用this调用其他的构造函数

1.public：公共权限 （修饰类，成员变量和成员函数）package org.wudroid;//类名就必须与文件名一致public class Person{ String name;//此时在另一个包中的类不可以调用这个成员变量. public int age; public void introduce(){ System.out.println("name"); }}//没有任何限制，即使在不同包里也可以调用。//如果一个类不是公共的,在不同的包的类中是无法使用的.2.private：稀有权限（同上）package org.wudroid;//类名就必须与文件名一致class Person{ private String name; private int age; privatevoid introduce(){ System.out.println(name); }}//只能在内部类当中使用，切记！即使在同一个包中是“不可以”调研其他类中的私有的成员变量和成员函数的。3.default：包级别访问权限不写权限修饰符就是default权限；在同一个包中，可以自由访问protected：受保护权限未讲！5.导入包，指在类中调用另一个包中的类，方便调用时不需要在输入长长的包名，一句搞定：import ...eg:package org.wudroid.Person;import com.wudroid.Person; or import com.wuroid.*;class ....

对象使用方法对象.变量对象.函数（）多对象使用方法new为创建一个对象，有多少new，就创建了多少对象，而且他们在堆内存都有独立空间，不会相互干扰，并且以对象名字表示自己的对象实体。匿名new ...().jump();一次性使用，或许有重复，但他们代表的不是同一个对象，而是重新开辟新的空间。

继承并不能解决问题，而要考虑权限eg：公共和默认1.package org.wudroid;/*如果子类和父类不在同一个包中,则子类无法继承到父类当中的默认权限(default)的成员变量和成员函数*//*如果子类和父类不再同一个包中,子类可以继承到父类的default权限的成员变量和成员函数,但由于权限不够,无法使用*/public class Person{ String name; int age; void eat(){ System.out.println("eat"); } void sleep(){ System.out.println("sleep"); }}2.package org.wudroid;//此时不用调用外包即可继承父类和父类的成员变量和成员函数class Student extends Person{ void introduce(){ System.out.println("我的名字是" + name + "我的年龄是" + age); }}eg：private权限只限在本类中使用，而不可在别的类中使用，即使在同一个包里。重点：protected//protected权限首先拥有和default一样的功能，但该权限只能修饰成员变量和成员函数//只允许子类和父类继承关系在不同的包中使用成员变量和成员函数，public在没有任何//继承关系都可以在不同包中使用成员变量和成员函数

分支语句中的if...else: if...else...1.if(布尔类型表达式){  语句1;  语句2;.....}真则执行该语句，否则跳过或者执行2。2. ..... else{ 语句1;......} 3.有多种判断语句 ...... else if(布尔类型表达式){ .....;} else if(布尔类型表达式){ .....;} else if(布尔类型表达式){ .....;} ......Swith语句：swith(表达式){ case常量1:（冒号） 语句1; break; case N.... 【default： 语句1； break；】可有可无}一直执行的语句，相比if..else...的选择运行语句更占用内存。break：从匹配代码开始，如果无break；则后面代码依旧执行，所以每条语句应当养成break的习惯，免得出现错误。

static 关键字 有3个特点1.定义静态成员变量的语法特点2.定义静态函数的语法特点3.定义静态代码块的特点下面就一一述说：1.定义静态成员变量的语法特点class Person{ static int i;}class Test{ public static void main(String arge[]){ Person p1 = new Person(); Person p2 = new Person(); Person.i = 10;//可以使用类名来调用静态的i System.out.println("p1的i的值为" + p1.i); System.out.println("p2的i的值为" + p2.i); p1.i = 20;//静态的情况下输出的值都为i的值，修改后就为修改后的值。 System.out.println("p1的i的值为" + p1.i); System.out.println("p2的i的值为" + p2.i); }}注： 1.可以使用类名来调用，也可以使用对象名来调用。 2.静态的成员变量的对象使用的都是同一个值 3.静态不是对象层次的变量，而是类层次的变量，他不属于对象，属于类。类生成的所有对象使用的都是用一个静态成员变量，当某个对象跟着改，其他的对象值也跟着改2.定义静态函数的语法特点class Person{ static String name; //上下也必须是静态才可互相调用。因为可以直接用类名调用，这样name就无法使用了（这点还稍微有点不懂，为什么静态函数只能调用静态成员变量？） static void talk(){ System.out.println("my name is " + name); }}class Test2{ public static void main(String arge[]){ Person.name = "zhangsan"; Person.talk(); //都可直接使用类名调用 }}注： 1.静态函数前加static关键字 2.静态函数可以直接用类名调用 3.在静态函数当中不可以使用非静态的成员变量3.定义静态代码块的特点 class Person{ static { System.out.println("我是静态代码块");//静态代码块没有名字，装载类的时候就执行该代码块，使用比较少！ } static String name; //上下也必须是静态才可互相调用。因为可以直接用类名调用，这样name就无法使用了（这点还稍微有点不懂，为什么静态函数只能调用静态成员变量？） static void talk(){ System.out.println("my name is " + name); }}注: 1.静态代码块没有名字 2.在本类装载的时候就执行该代码块

这节课其实很简单，就是你继承你老爸给你的东西，但不是死后，是永远取之不尽的。只要加上extends+你老爸的名字就行了。 好处：1.减少不必要的重复代码，减少修改2.继承父类的基本语法， 继承后子类只需添加自己需要的成员变量和成员函数就可以了，依旧可以在子类里调用父类的成员变量和成员函数。

重点：extends是不可以继承父类的构造函数的，只能继承父类的成员变量和成员函数。用super()就可以调用父类的构造函数了。解决了两个类当中的构造函数里重复的代码。eg：class Person{ String name; int age; Person(){ System.out.println("person的无参构造函数"); } Person(String name,int age){ this.name = name; this.age = age; System.out.println("person的有参数构造函数"); } void eat(){ System.out.println("吃饭"); }}class Student extends Person{ int grade; //在子类的构造函数当中,不需调用父类的构造函数(自动生成!)? Student(){ super();//像this，里面的参数决定用父类的构造函数 System.out.println("students的无参构造函数"); } Student(String name,int age,int grade){ //this.name = name; //this.age = age; super(name,age);//解决了上方的父类的重复代码 this.grade = grade; }}主函数：class Test{ public static void main(String arge[]){ Student student = new Student("zhangsan",18,3); System.out.println(student.name); System.out.println(student.age); System.out.println(student.grade); //调用student类是，会先调用student的父类。 }}结果可想而知，输出的是student的有参的构造函数，并且先编译person的有参构造函数，在编译student的有参构造函数。

 定义了接口，就是定义了调用对象的标准。 借口基本语法：1.使用interface定义；2.接口当中的方法都是抽象方法；3.接口当中的方法都是public权限；interface USB{public void read();//抽象方法，接口里必须都是抽象方法 public void write();}接口的基本语法2：1.实现接口的使用implements关键字；2.一个类可实现多个接口；//实现implements（必须复写实现的接口,有多少个接口就必须复写接口里的方法）;可实现多个接口class Phone implements USB,WIFI{//类1 public void read(){ System.out.println("USBPhone read"); } public void write(){ System.out.println("USBPhone write"); }//类2 public void open(){ System.out.println("wifi open"); } public void close(){ System.out.println("wifi close"); }}3.一个接口可继承多个借口；interface A{ public void funA();}interface B{ public void funB}//extends，为什么用继承？因为不需要复写，这是接口的特性。interface C extends A,B{ public void funC();}

在子类继承父类的同时，发现某一方法不适合自己，需要做修改，这种情况就是复写。super第二种用法:调用父类的成员函数eg:class Person{ String name; int age; void introduce(){ System.out.println("我的名字是" + name + "我的年龄是" + age); }}class Student extends Person { String address; void introduce(){ super.introduce();//调用父类的introduce的代码 System.out.println("我的地址在" + address); //这就是复写，其实就是覆盖或者重写：override //特征:1.在具有父子关系的两个类当中 //2.父类和子类各有一个函数,这两个函数的定义(返回值类型,函数名和参数列表)完全相同。 }}class Test{ public static void main(String arge[]){ Student s = new Student(); s.name = "zhangsan"; s.age = 20; s.address = "beijing"; s.introduce(); Person p = new Person(); p.name = "lisi"; p.age = 20; p.introduce(); }}编译后会发现，调用子类的函数会输出子类方法复写后的代码，调用父类的函数只输出父类的方法的代码

向上转型：生成一个子类的对象，然后赋值给父类的引用要有继承的关系，子类的对象赋值给父类的对象才没有问题student ——person茶杯 —— 杯子笔记本 —— 电脑 为什么向上转换，有什么用？将类型向上转型，更加抽象，更加全面。 向下转型：必须把对象先向上转型，后把对象向下转型（强制转换）。细节不清楚，欲知后事如何，请听下回分解。

eg：char c = '0'为字面量；化 整数为整形（int） 小数为双精度浮点型（double）切记：不可将大的值的类型赋予小的类型，不是不可，而是缺失精度。强制转换eg:byte b = （int）.....可能会返回错误结果，慎用！数据类型表数范围关系：byte<short<int<long<float<double

重载：名字相同，但行为是不同的，比如都是“洗”，如何洗碗，洗衣服，清洗电脑……1.两个或多个函数在同一个类当中2.函数名相同3.参数列表不同构造函数：类名+（），eg: new A（）不做成员函数eg: A(){       }//无参的构造函数1.没有返回值类型；2.必须和类名相同；3.编译器在编译时自动生成无参数的构造函数eg:A(String n, int a ){ name = n; age = a;}// 可有多个 有参的构造函数构造函数的重载也是一个非常重要的语法如果有构造函数编译器则不生成无参的构造函数

类的定义和对象的定义对象本体存放于堆内存，对象名存放于栈内存。对象名引用于对象本体，其实对象名专业术语叫做“引用”，所以称为引用数据类型。生成对象的方法是个重点，在以后编程有很大的帮助，必须理解

被客户不断变化的需求“折磨”或许是客户的需求有所改变；或许是客户根本不知道需要什么而改变。在用户需要改变时，程序代码需改变大，重写类时多出了许多重复代码。怎么办？答：使用前面使用的继承，this语句和super语句。（代码需要高维护性，高拓展性）