java基础
JAVA基础：（个人理解，刚开始学，有错误麻烦大家纠正，谢谢.）
1、修饰符 class 类名
{
//Do something;
}
public static void main(String[] args){
这属于函数入口
}
2、数组：int x[] = new int[100];
3、成员变量、局部变量
4、get/set 实现类似属性访问
public class Person{
private int age;
public int getArea(){
return age;
}
public void setArea(int i){
this.age = age;
}
}
5、类的初始化
Person p1=new Person();
new Person().getArea();
6、构造函数
一般应用是对于初始化赋值
在Java中至少又一个构造方法，我们没有写，系统会自动产生一个默认构造方法
在构造方法里不含返回值的概念是不同于“void”的,对于“public void Per son( ) ”这样的写法就不再是构造方法,而变成了普通方法,很多人都会犯这样的错误,在
定义构造方法时加了“void”,结果这个方法就不再被自动调用了。
对构造方法进行重载：
class Person{
public Person(){
System.out.println("构造方法");
}
public Person(String n){
name = n;
System.out.println("构造方法重载");
System.out.println("name="+name);
}
public Person(String n,int m){
name = n;
age = m;
System.out.println("构造方法重载");
System.out.println("name ="+ n+"age ="+m);
}
public void shout(){
System.out.println("打印方法");
}
}
//调用class
class TestPerson{
public static void main(String[] args){
Person p1 =new Person();
p1.shout();
Person p2 =new Person("Jack");
p2.shout();
}
}
构造方法的重载的作用是可以根据传入参数不同，对对象进行不同的初始化；
ps：构造函数一般都是用public修饰，不能用private，因为它们在对象产生时会被系统自动调用。
7、this引用句柄，
1）其实就是对本类中，各个方法之间要调用其中一个方法的时候用this来指定。
2）还有就是在外部参数传入的参数名和成员变量名相同的时候，必须用this来指定成员变量名以示区分，例如：this.name = name;
3) 另外一种，假设我们有一个容器类和一个部件类,在容器类的某个方法中要创建部件类的实例对象,而部件类的构造方法要接收一个代表其所在容器的参数,程序代码如下:
class Cintainer{
Component comp;
public void addComponent()
{
comp = new Component(this);//将this作为对象引用传递 }
class Component{
Container myContainer; public Component(Container c) {
myContainer = c;
}
4)构造方法是在产生对象时被Java系统自动调用的,我们不能在程序中象调用其他方法 一样去调用构造方法。但我们可以在一个构造方法里调用其他重载的构造方法,不是用构造方 法名,而是用 t hi s( 参数列表) 的形式,根据其中的参数列表,选择相应的构造方法
public class Person {
String name;
int age;
public Person(String name)
{
this.name = name;
}
public Person(String name,int age)
{
this(name);
this.age = age;
}
}
public void finalize()作用是当对象被当成垃圾从内存中释放前调用，而不是变成垃圾前调用。finalize()不是完全可靠地每次都会调用。
析构函数是在对象即将消亡之前调用的方法，那么结合前面的构造函数：我们就可以提前对对象的产生和消亡过程进行一些控制。但要知道的是：无论是构造方法被调用,还是析构方法被调用,对象都在内存中存在。
8、在有些情况下，我们需要自行通知系统进行垃圾回收时，这个时候我们就需要调用System.gc()方法强制启动垃圾回收
9、static关键字，以及静态方法，静态代码块
修饰成员变量的时候，在引用它的时候不需要为该类去创建对象，它会一直保留在内存当然，知道程序结束
修饰方法的时候，我们可以用类名来访问方法，而不需要为该类创建对象
在使用类的静态方法时,我们要注意以下几点:
1) 在静态方法里只能直接调用同类中其它的静态成员(包括变量和方法),而不能直接访问
类中的非静态成员。这是因为,对于非静态的方法和变量,需要先创建类的实例对象后才可使 用,而静态方法在使用前不用创建任何对象。
2) . 静态方法不能以任何方式引用 t hi s 和 super 关键字。与 上面的道理一样,因为静态方法在使用前不用创建任何实例对象,当静态方法被调用时,t hi s 所引用的对象根本就没有产生。
3) . main() 方法是静态的,因此 JVM在执行 main 方法时不创建 main 方法所在的类的实例对象,因而在 main() 方法中,我们不能直接访问该类中的非静态成员,必须创建该类的一个实例 对象后,才能通过这个对象去访问类中的非静态成员,这种情况,我们在以后的例子中会多次 碰到。
另外就是静态代码块：
一个类中可以使用不包含在任何方法体中的静态代码块(static block ),当类被载入时, 静态代码块被执行,且只被执行一次,静态块经常用来进行类属性的初始化。
10、单态模式（IOS中的单例）：
所谓类的单态设计模式,就是采取一定的方法保证在整个的软件系统中,对某个类只能存 在一个对象实例,并且该类只提供一个取得其对象实例的方法。 例如：
public class Single
{
private static final Single onlyOne = new Single();
public static Single getSingle(){
return onlyOne;
}
private Single(0{}
}
11、内部类,应用非常多，可以使程序更具模块化，编写更容易，只需要记住内部类可以访问外部类成员，但是反过来就不成立，内部类只有在它的内部类范围之内是可知的，不被外部类使用。
class Outer {
int outer_i = 100;
void test() {
Inner in = new Inner();
in.display();
}
class Inner {
void display()
{
System.out.println("display: outer_i = " + outer_i); }
} }
class InnerClassDemo {
public static void main(String[] args) {
Outer outer = new Outer();
outer.test();
}
}
当需要从外部类之外被调用，只要将内部类用public进行修饰；
ps:方法中也能定义内部类，不只是可以在类中定义；在方法中定义的内部类只能访问方法中的 f i nal 类型的局部变量,因为用 f i nal 定义的局 部变量相当于是一个常量,它的生命周期超出方法运行的生命周期。
class InOut {
String str= new String("Between"); public void amethod(final int iArgs) {
int it315; class Bicycle {
public void sayHello() {
System.out.println(str); System.out.println(iArgs);
}//End of bicycle class }
}//End of amethod }
在内部类中的 sayHel l o 方法中,我们可以访问变量 i Ar gs 和 st r ,但不能访问 i t 315。
12、类的继承，Java只支持单继承，不允许多重继承，亦是一个子类只能有一个父类，不允许一个类直接继承多个类；
但是可以多层继承
class A{}
class B extends A{}
class C extends B{}
子类继承父类所有的成员变量和成员方法,但不继承父类的构造方法。在子类的构造方
法中可使用语句super(参数列表) 调用父类的构造方法。如:我们为Student类增加一个构造 方法,在这个构造方法中我们用 super 明确指定调用父类的某个构造方法。
class Student extends Person {}
public Student(String name,int age,String school) {
super(name,age);
this.school=school;
}
如果子类的构造方法中没有显式地调用父类构造方法,也没有使用 t hi s 关键字调用重 载的其它构造方法,则在产生子类的实例对象时,系统默认调用父类无参数的构造方法。
在类的继承中，子类也同样可以覆盖父类的方法，若想调用父类方法，可以使用super.method();
13、 final关键字
在 Java 中声明类、属性和方法时,可使用关键字 f i nal 来修饰。
f i nal 标记的类不能被继承。
f i nal 标记的方法不能被子类重写。
f i nal 标记的变量( 成员变量或局部变量) 即成为常量,只能赋值一次，也只能在定义时赋值。
14、abstract （修饰抽象类）
抽象类必须用 abstract 关键字来修饰;
抽象方法也必须用 abstract 来修饰。
抽象类不能被实例化,也就是不能用 new关键字去产生对象。
抽象方法只需声明,而不需实现。
含有抽象方法的类必须被声明为抽象类,抽象类的子类必须覆盖所有的抽象方法后才能被实例化,否则这个子类还是个抽象类。
抽象方法的写法:
abstract 返回值类型 抽象方法( 参数列表 );
抽象类和抽象方法的例子:
abstract class A
{
abstract int aa(int x,int y);
} 注意:含有抽象方法的类肯定是抽象类,抽象类中的某个方法不一定是抽象的。
15、interface（接口）
interface,接口是一种特殊的抽 象类,这种抽象类中只包含常量和方法的定义,而没有变量和方法的实现。
public interface Runner{
int iD = 1;
void run();
}
我们可以用extends关键字去继承一个已有的接口，也可以定义一个类用implements关键字去实现一个借口中的所有方法，
还可以去定义一个抽象类用implements关键字去实现一个接口中定义的部分方法；
interface Animal extends Runner{
void breathe();
}//是一个接口，对Runner进行扩展
class Fish implements Animal{
public void run()
{
System.out.println("fish is swimming !");
}
public void breathe(){
System.out.prinln("fish is bubbling !");
}
}//是一个类，具有animal接口中所有的方法，必须实现这些方法；
abstract LandAnimal implements Animal{
public void breathe(){
System.out.prinln("LandAnimal is breathing");
}
}//是抽象类，但没有实现Run方法，Run在LandAnimal就成了一个抽象方法，LandAnimal就是抽象类；
interface的目的就是达到多重继承的目的。一个类可以在继承一个父类的同时，实现一个或多个接口，extends关键字必须位于implenments关键字之前；例如：
class Student extends Person implements Runner{};
PS:
实现一个接口就是要实现该接口的所有方法(抽象类除外)。
接口中的方法都是抽象的。
多个无关的类可以实现同一个接口,一个类可以实现多个无关的接口。
16、对象的类型转换
用instanceof 可以判断某个类实现了某个接口，也可以判断一个实例对象是否属于一个类
public static void CallA(A a) {
if(a instanceof B) {
B b=(B)a;
b.func1();
b.func2();
b.func3();
} else {
a.func1();
a.func2();
}
}
instanceof 的用法:
对象 instanceof 类(或接口)
它的返回值是布尔型的,或真(t r ue),或假(f al se)。
17、异常处理（try...catch）、throws
try
{
/*代码块*/
}
catch(Exception e){
System.out.println("抛出异常");
}
throws，当某一个类用throws修饰的时候，另外一个类实例化它的时候就必须做出异常处理。
