java部分基础总结

新手期一些知识的总结
面向对象：
首先先将面向对象与面向过程区分开：面向过程主要是通过过程，达到某种目的，这种目的的目标就是对象，二面向对象重点则是不再考虑过程，直接面向对象！
对象
概念：一切客观存在的能够区分开的单个物体。（万物皆对象。）
组成：属性、行为
类
概念：若干具有相同特征或者共性的对象的抽象
组成：属性、行为
语法：[修饰符] class 类名{   }(修饰符为public时类名必须与源文件名保持一致（只能用public或者缺省）)
结构：
1.成员变量----属性----字段  [修饰符] 数据类型 变量名 [=初始值]
2.构造器----构造方法----构造函数（是特殊的成员方法） [修饰符] 类名([数据类型 参数名]){ } 
   构造器名必须与类名保持一致，无返回类型（包括void）,任何类都含有构造器。如果没有显式的构造器，那么系统会为该类提供一个默认的无参构造器，如果有显式的那么系统不再提供。
   构造器作用：1.实例化类的对象2.初始化成员变量。
3.成员方法----行为----函数  [修饰符] 返回值类型 方法名([数据类型 参数名]){ }
4.代码块  { }或者static{ }（二者区别：前者必须使用一个对象（new 构造器名()），后者无需）
使用：
1.类变量的声明：类名 对象名；
2.类对象的创建：对象名=new 构造器名();
3.类属性的赋值：对象名.属性名=数据（也可叫属性值）（数据类型与对象名类型保持一致）
4.类属性和方法的调用：System.out.println(对象名.属性名);、对象名.方法名([数据类型 参数])；
注：1.自定义的类可以作为引用数据类型声明变量！（参照类的使用）2.参数：特殊的局部变量，通过实参传递数据给形参。
重载(Overloading)
概念：在同一类中，定义了多个方法名相同，参数不同的方法。（参数的不同：参数的类型、数量、顺序不同）
使用：方法的重载、构造器的重载
this关键字
概念：每一个类都隐含有一个当前类的对象
使用：1.this.成员（成员变量和成员方法）2.在构造器内的第一行语句可以调用该类内其他重载的构造器来完成自己的初始化：this([数据，数据，……]);
类成员与实例成员
概念以及区别：
1.有static修饰的是类成员，没有static修饰的是实例成员。
2.类成员是一个类内所有对象共有的，实例成员是一个类内一个对象独有的
3.类成员能直接访问所有成员（无论是否是类成员），实例成员只能够直接访问实例成员，如果要访问类成员必须先创建一个对象。
4.类成员的调用可以先创建一个对象，也可以直接用 类名.成员 直接调用，实例成员必须先创建一个对象。
5.类成员不可以使用this关键字。（因为没有this的实例可以使用）
包
包的声明：1.在源文件的第一行语句 package 包名.包名  2.包名一般是域名的倒置。
包的导入：import 包名.包名.类名  在声明的包下面，声明的类上面。
修饰符
访问修饰符:
1.public：在同包下与非同包下都可以访问。
2.protected：在同包下可以访问，在非同包下的子类可以访问。
3.缺省：在同包下可以访问，非同包下不可以访问。
4.private：只有在类内能够访问。
非访问修饰符：
1.static 静态
2.final  修饰类：该类不能够被继承  修饰成员变量：为常量不可修改  修饰方法：不能够被重写  修饰参数：在方法体中不能够被赋值。
3.abstract  抽象
返回值类型：
void还有八大数据类型：byte short  int  long  float double char boolean
return：在有返回值的方法体中，最后一行返回一条数据，结束方法体，在void方法体中结束方法体。
对象的四大特点
封装、继承、多态、抽象
封装
概念：把成员（属性和方法）私有化（private），只为可信任的类提供访问。（）
使用：提供public的get和set方法进行访问。
继承
概念：在现有的类上派生出一个新的类。把类具有的相同代码提取出来，成为父类，其他类继承，减少代码的冗余。
使用：[修饰符] class 子类名 extends 父类名 { }  
注：子类继承父类后，会拥有父类的非私有的属性的方法。  子类创造对象时本质上是创造了两个对象，一个子类对象（子构造器），一个隐含的父对象（父构造器 super）
      （子类无法继承父类的构造器）
重写（Override）
概念：在继承关系的前提下，父类方法无法满足子类方法的需求，这样子类方法就会重新改写（重写或者覆写）
使用：1.继承 2.子类的方法与父类方法的返回值类型、方法名、参数必须一致，但是方法体内必须不同。3.修饰符可以不同，但是子类修饰符访问范围要大于或等于父类
super关键字
概念：子类都隐含有一个父类的对象。
使用：1.super.成员 2.在子类构造器内的第一行一句（super([参数列表]);）默认的调用父类的无参的构造器。
多态
概念：一种事物的多种形态。
使用：1.继承 2.重写 3.向上转型（父类名 父类对象名=new 子类构造器名();）
作用：1.提高代码的可重用性 2.降低程序间的耦合度。
抽象类
关键字：abstract
抽象方法（不完整的方法）：[修饰符] abstract 返回值类型 方法名([数据类型 参数名]);
抽象类
概念：有抽象方法的类就是抽象类（不完整的方法）。
内容：抽象类有构造器，也可以声明变量，但是却不可以实例化，因为它拥有不完整的方法，它是不完整的类。抽象类中可以有完整的方法，但是有抽象方法的类一定是抽象类。
使用：抽象类可以被继承，通过子类来完整方法，进而达到抽象类的实例化。（用到多态向上提型）
接口
接口类的声明：[修饰符] interface 接口名（与源文件名保持一致）{ }
概念：更加抽象的抽象类（更加不完整的不完整类，本质也是类，但是它没有构造器）
结构：1.常量  [修饰符]  [final] 数据类型 变量；2.抽象方法 [修饰符] abstract 返回值类型 方法名([数据类型 参数名]);（1.8版本以上的有改动，比如添加不同修饰符可以有完整的方法。目前忽略）
使用：1.类实现接口：[修饰符]class 子类名 extends 父类名 implements 接口名,接口名,……{ }（class实现接口时extends与implemnts顺序不可改变）
          2.接口继承接口 [修饰符] interface 接口名 extends 接口名,接口名,……{ }
作用：1.提高了代码的重用性  2.减少了程序间的耦合度 3.实现了多继承 4.提高了程序的可拓展性  
instanceof运算符
概念：判断一个对象是不是某个类的实例。 
使用：if （对象名 instanceof 类名）  {   }等等
内部类
成员内部类：在一个类中，方法体外再定义一个类。
1.外部类访问内部类：需要先创建一个对象，然后对象名.内部类成员。
2.内部类访问外部类：可以直接访问外部类成员：外部类名.this.外部类成员
3.外部其他类访问内部类：外部类.内部类  内部类对象名=new 外部类构造器().new 内部类构造器();内部类对象名.内部类成员;
局部内部类：在一个类的方法体中再定义一个类。
1.外部类访问内部类：需要先在外部类方法体中，声明内部类后，创建一个对象，然后调用成员。
2.内部类访问外部类：可以直接访问外部类成员，包括private类。不能访问外部类方法体中的变量。外部类名.this.外部类成员
3.外部其他类访问内部类：无法直接访问，可以通过外部类来获得其内容。
静态内部类：在一个类中，方法体外再定义一个类，这个类用static修饰。
1.外部类访问内部类：有static修饰的内部类成员：内部类名.内部类成员  无static修饰：创建内部类对象，然后访问。
2.内部类访问外部类：外部类成员如果没有static修饰，那么就需要先创建一个外部类对象，如果有static修饰那么久可以直接外部类名.外部类成员
3.外部其他类访问内部类：无static修饰内部类成员：1.外部类.内部类  内部类对象名 =new 外部类.内部类构造器名();内部类对象名.内部类成员;有static修饰的内部类成员：2.外部类.内部类.内部类成员；
匿名内部类：本质上是内部类的缩写。
1.外部类访问内部类：new 父类或者接口(){ 重写方法体}.方法名;
2.内部类访问外部类：可以直接访问外部类成员，包括private类。不能访问外部类方法体中的变量
3.外部其他类访问内部类：无法直接访问。