1. abstract抽象
什么是abstract，中文为抽象，从具体事物抽出，概括它们共同的方面，本质属性与关系等，称为抽象。看不见，摸不着的东西叫做抽象，抽象是人们对世界万物的感觉，用特定的图像表达出来，要理解抽象的东西，就必需从内心感受它们。
什么是抽象类
抽象类的定义和使用格式
abstract class 类名{
类体
}
class 类名 extends 抽象类 {
//实现全部抽象方法
}
抽象类，用abstract修饰的类为抽象类，一个类如果它的所有子类都重写了这个方法，那么给它添加抽象的声明，那么这个类就为抽象类。
那么这个抽象方法的类就为抽象类，具有抽象方法的类为抽象类，但抽象类不一定具有抽象方法，抽象类中可以有构造方法，不能创建对象。
抽象类中如果有抽象方法，那么子类继承这个抽象类之后，就必须要重写抽象类中的 所有抽象方法。
一个类用abstract进行修饰为抽象类，那么这个抽象类不能在用final来修饰了，抽象类是类对象的抽象集合，抽象类使用abstract关键字修饰，abstract不能与final并列修饰同一个类。
对于抽象方法，不能在用
static和final和private来修饰
在抽象类中具体抽象的是属性和行为，在抽象类中，含有抽象方法的类为抽象类，一定是抽象类，但抽象类中不一定含有抽象方法。
案例：
//抽象类：作为抽象方法是可以重载的
public abstract class Person {
public abstract void run();
}
//子类继承抽象类
public class Studentone extends Person{
@Override
public void run(){
System.out.println("人会跑");
}
}
//测试
public class Test {
public static void main(String[] args){
Person person = new Student();
person.run();
}
}
//结果
人会跑
2. 接口
什么是接口（interface）
接口中的方法都是抽象方法，public权限，全是抽象函数，不能生成对象
interface Student{
public void read();
public void write();
}
class ChineseStudent implements Student{
//复写
public void read(){
System.out.println("read");
}
public void write(){
System.out.println("write");
}
}
class Test{
public static void main(String args[]){
ChineseStudent chinesestudent = new ChineseStudent();
Student student = chinesestudent;
student.read();
student.write();
}
}
接口的定义和使用格式
interface 接口名 {
[public] [static] [final] 变量;
[public] [abstract] 方法;
}
class 类名 implement 接口列表 {
//实现所有接口中声明的方法
}
什么是接口呢？这个类中所有的方法都是抽象方法。
接口不同抽象，没有构造方法，接口不是一个类。
接口中也不能创建对象，抽象方法也不能。
在JDK1.8以前，interface来定义接口，通过implements关键字让接口和类产生关系，类实现接口，要重写接口中的所有抽象方法。
在Java中只有单继承，多实现，一个类可以继承一个父类，但一个类可以实现多个接口。
实现接口用implements关键字，
一个接口可以实现多个接口，
一个接口可以继承多个接口
interface Student{
public void read();
public void write();
}
interface Teacher{
public void teach();
public void test();
}
class Person implements Student,Teacher{
public void read(){
System.out.println("read"):
}
public void write(){
System.out.println("write");
}
public void teach(){
System.out.println("teach"):
}
public void test(){
System.out.println("test"):
}
}
// 测试
class Test{
public static void main(String args[]){
Person person = new Person();
Student student = person;
student.read();
student.write();
Teacher teacher = person;
teacher.teach();
teacher.close();
}
}
接口解决了多继承的问题，将多继承的这种机制在
java中通过接口实现了，接口与接口之间是继承的关系。
interface A{
void showa();
}
interface B{
void showb();
}
class C implements A,B{
public void showa(){};
public void showb(){};
}
接口中的属性默认是使用public static final修饰的
interface A {
void add();
}
class B implements A {
// 接口中的方法默认是使用public修饰
void add(){}
}
实现多接口，存在方法名一致时，会导致方法重写的时候产生歧义。
抽象类和接口比
- 抽象类是对类抽象，而接口是对行为的抽象。
- 抽象类为继承关系，接口为实现类与接口之间的契约关系。
- 抽象类为单继承，接口为多“继承”。子类只能继承一个抽象类，但可实现多个接口。
代码
//抽象类
abstract class Person {
abstract void run();
abstract void jump();
}
//接口
interface School{
void go();
}
//实现
class Student extends Person implements School{
void run();
void jump();
void go();
}
抽象类中成员变量默认为
friendly，函数修饰符public，protected，default。
接口属性为静态，
public static final，成员函数为public。
3. 内部类
内部类的分类：
- 静态内部类
- 局部内部类
- 成员内部类
- 匿名内部类
// 外部类
class Demo{
private int num = 3;
// 定义内部类
class Int{
void show(){
System.out.println("num="+num);
}
}
void method(){
Int int = new Int();
int.show();
}
}
class Inner{
public static void main(Stirng[] args){
Demo demo = new Demo();
demo.method();
}
}
内部类有 非静态，静态，匿名类
语法:
new 外部类().new 内部类()
成员内部类：
在成员变量的位置上定义的类为成员内部类。
如果要使用成员内部类就要使用外部类.内部类来访问。
静态内部类：
在成员位置上用static修饰的内部类为静态内部类。
静态内部类只能访问外部类的静态成员和本内部类的成员；且不能访问外部类的非静态成员。
匿名内部类：（对应类的子类或者对应接口的实现类）
是一种特殊的局部内部类。
访问外部类中的内部类，非静态
Outer.Inner int = new Outer().new Innter();
对静态内部类中的非静态成员
Outer.Inner int = new Outer().new Innter();
用static声明的内部类，则内部类变成外部类，用static声明的内部类不能访问非static的外部类属性，外部类的属性要用static才能访问。
内部类可以使用外部类所有的方法和变量，就算被私有化也一样可以，如：
class Outer{
private int x;
// 创建内部类的实例
Inner inner = new Inner();
public void do(){
// 调用内部类的方法
inner.go();
}
// 内部类
class Inner{
void go(){
x = 30;
}
}
}
4. 包
在java中提供了不同的类和接口存放在不同的包中。
常见的包
java.applet
java.awt
java.net
java.util
java.lang
java.awt GUI
java.io 数据传输
java.math 数学运算
java.nio 高并发
java.net 网络编程
java.text 格式化
java.sql 和数据库交互
包的格式：
package 包名[.子包名[…]];
引入java包
import 包层次结构的类名;
垃圾分代回收机制
垃圾分代回收机制针对堆内存，所有内存由Java自动分配到回收，垃圾收集器。
结语
- 下面我将继续对
Java、Android中的其他知识 深入讲解 ，有兴趣可以继续关注 - 小礼物走一走 or 点赞