-----------android培训、java培训、java学习型技术博客、期待与您交流！ ------------
类与类之间的关系：继承，聚集。
对于多个类*有的属性方法，则可以提取出来，定义成一个父类。一个类继承另一个类，这个类就有了被继承类定义的属性，方法。
继承的好处：
1，提高了代码的复用性。
2，让类与类之间产生关系，从何实现多态的特性。
java中不支持多继承，只支持单继承。但支持对接口的多实现。接口对接口的多继承，
聚集关系：
聚合关系：如鼓手是乐队里的一部分。
组合关系：如手是身体的一部分。
变量：
如果子类出现非私有的同名变量时，子类要访问本类中的变量，用this。
子类要访问父类中的同名变量，用super。
super的使用和this的使用几乎一致，代表的是父类对象的引用。
当函数前面没有public,private定义权限时，系统默认权限(default)。此权限介于public private之间。
函数的覆盖：见第一篇的重载和覆盖的区别。
因为覆盖的条件，构造函数不可能存在覆盖。
加载子类文件的时候会先加载父类文件。因为在对子类的构造函数默认第一行有一条隐式的语句super();
super()会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super();
super()和this();只能出现一个。
因为父类中的数据子类可以直接获取，所以子类对象在建立时，需要知道父类是如何对这些数据进行初始化。
子类一定要访问父类中的构造函数。如果父类中没有空构造函数，或者要访问父类中指定的构造函数，则子类需手动定义super或者this语句来指定要访问的构造函数。
class ExtendsDemo
{
public static void main(String[] args)
{
Zi z = new Zi();
Zi z1 = new Zi(1);
}
}
class Fu
{
Fu()
{
System.out.println("我是父类");
}
Fu(int x)
{
System.out.println("我也是父类");
}
}
class Zi extends Fu
{
Zi()
{
//super();
System.out.println("我是子类");
}
Zi(int x)
{
//super();
System.out.println("我也是子类");
}
}
运行结果：
我是父类
我是子类
我是父类
我也是子类
关键字final:class Fu
{
int i;
public Fu(String s)
{
i =1;
}
public void print()
{
System.out.println("fu");
}
}
public class Zi extends Fu
{
public Zi(String s)
{
super(s);//不写这句话会编译失败。
i =2;
}
public static void main(String[] args)
{
Zi zi = new Zi("a");
System.out.println(zi.i);
}
}
1，可以修饰类，函数，变量。
2，被final修饰的类不可以被继承。
被final修饰的方法不可以被复写。
被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，也可以修饰局部变量。（当一些数据是固定的，可以加上final修饰。为了增强阅读性，可以给该数字起个名字。字母全部大写，多个单词直接用_链接。）
3，内部类定义在类中的局部位置上，只能访问该局部被final修饰的局部变量。
当定义一个类，不希望被继承的时候，可以将类用final修饰。如String类
抽象类：当多个类中有相同功能，但是功能主题不同，可以将次功能定义抽取出来，不抽取功能主体。
1，抽象方法一定在抽象类中。
2，抽象方法和抽象类必须被abstract关键字修饰。
3，抽象类无法创建对象。调用抽象方法没意义。
4，抽象类中的方法要被调用，必须由子类复写起所有的抽象方法后，建立子类对象调用。否则其子类也是个抽象类。
好处：强制子类实现其抽象功能。
模版方法模式：
在定义功能时，功能的一部分是确定的，一部分不确定。确定的部分使用不确定
部分，则可以把不确定部分暴露出去，让子类去实现。
class Stencil
{
public static void main(String[] args)
{
new SubGetTime().getTime();
}
}
abstract class GetTime
{
public final void getTime()
{
long start = System.currentTimeMillis();
runCode();
long end = System.currentTimeMillis();
System.out.println("运行时间："+(end-start)+"毫秒");
}
public abstract void runCode();
}
class SubGetTime extends GetTime
{
public void runCode()
{
for (int x=0;x<4000 ;x++ )
{
System.out.print(x);
}
}
}
接口：interface，接口是对外暴露的规则。对程序进行功能扩展。
接口特点：
1，接口常见定义：常量，抽象方法。
2，接口中的成员都有固定修饰符。
常量：public static final
方法：public abstract
接口中的成员都是public的，方法都是abstract
接口用来实现，用implements关键字。接口可以被类多实现。
类之间只有单继承，但接口之间有多继承。
多态：事物存在的多种体现形态。
1,多态的体现：
父类引用指向子类对象。父类的引用也可以接受自己的子类对象。
2，多态的前提
类与类之间存在关系，继承或者实现。
3，多态的好处与弊端
好处是提高了程序的扩展性，弊端是只能使用父类的引用访问父类中的成员。
还有就是通常存在方法的覆盖。
父类引用指向子类对象，如果调用的方法父类中没有。则编译失败。
当父类中有该非静态方法，运行时调用的是子类覆盖后的方法。
注意：
1，多态中，对于成员变量和静态成员函数，无论编译和运行，都参考引用变量所属的类。2，父类引用指向子类对象时，子类对象类型被提升。如果想使用子类的特有方法，可以强制将父类的引用，转成子类类型。
abstract class Student
{
public abstract void study();
public void sleep()
{
System.out.println("躺着睡");
}
}
class BaseStudent extends Student
{
//实现study方法
public void study()
{
System.out.println("base study");
}
//覆盖sleep()方法
public void sleep()
{
System.out.println("坐着睡");
}
public void play()
{
System.out.println("玩游戏");
}
}
class AdvStudent extends Student
{
public void study()
{
System.out.println("adv study");
}
}
class DoStudent
{
public void doSth(Student stu)
{
stu.study();
stu.sleep();
}
}
class DuoTaiDemo
{
public static void main(String[] args)
{
DoStudent ds = new DoStudent();
ds.doSth(new AdvStudent());
Student s = new BaseStudent();//父类引用指向子类实例对象。
ds.doSth(s);
BaseStudent b = (BaseStudent)s;//将Student类型引用变量s强转成BaseStudent类型。
b.play();
}
}
Object类，所有对象的直接或间接父类。
几个比较常见的方法：
boolean equals(Object obj)int hashCode() 返回该对象的哈希码值
void notify() 唤醒在此对象监视器上等待的单个线程。
void notifyAll() 唤醒在此对象监视器上等待的所有线程。
String toString() 返回该对象的字符串表示。
void wait() 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。
内部类：
将一个类定义在另一个类里面。一个事物里面还有事物的时候可以定义内部类。一般内部类都被私有化，通过对外提供方法进行访问。
访问特点：1，内部类可以直接访问外部类里的成员，包括私有成员。因为内部类中持有了外部类的引用：外部类名.this
2，外部类要访问内部类中的成员必须建立内部类的对象。
访问格式：
1，当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中，直接建立内部列对象。
建立格式：外部类名.内部类名 变量名 = 外部类对象.内部类对象
Outer.Inner in = new Outer().new Inner();
2，当内部类在成员位子上，就可以被成员修饰符所修饰。eg:private static
当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。
访问静态内部类中的非静态成员function方法：new Outer.Inner().function();
访问静态内部类中的静态成员function方法：Outer.Inner.function();
注意：当内部类中定义了静态成员，该内部类必须是static的
当外部类中的静态方法访问内部类时，内部类也必须是static的
1，不可以被成员修饰符修饰，则不能被私有，不能被静态。
2，虽然可以直接访问外部类中的成员。但是不可以访问它所在局部中的变量。只能访问被final修饰的局部变量。
class Outer匿名内部类：
{
private int x = 0;
class Inner()
{
int x =4;
void function()
{
int x =6;
System.out.println(x);
//System.out.println(Outer.this.x)
}
}
void method()
{
//建立内部类对象，使用内部类方法。
Inner in = new Inner();
in.function();
}
}
class InnerClassDemo
{
public static void main(String[] args)
{
Outer out = new Outer();
out.method();
}
}
前提：内部类必须是继承一个类或者实现接口。
格式：new 父类或者接口(){定义子类的内容}。
匿名内部类就是一个匿名子类对象。匿名内部类中定义的方法最好不要超过三个。
class Fu
{
public void print()
{
System.out.println("fu");
}
}
public class Inner
{
public static void main(String[] args)
{
//匿名内部类
new Fu(){
public void print()
{
System.out.println("zi");
}
}.print();
}
}
打印的结果是：zi;
以上算是java中的定义一个类的语法和应该注意的地方。
接下来就是运行时应该注意的情况。
-----------android培训、java培训、java学习型技术博客、期待与您交流！ ------------