版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/sunshunli/article/details/84350116
1.抽象类
抽象类往往用来表达对问题的抽象。
定义抽象类应该注意：
（1）abstract是定义抽象类的关键字，放在class的前面。
（2）abstract在方法中声明，则该方法则是抽象的方法，抽象方法是没有方法体的，即为实现。
（3）一个抽象类可以可以包含多个抽象方法，也可含有已实现的方法。
看一个例子：
public class Circle extends Shape{
public Circle(double dim) {
super(dim);
// TODO Auto-generated constructor stub
}
public double callAres() {
// TODO Auto-generated method stub
return 3.14*dim*dim;
}
public double callPerimter() {
// TODO Auto-generated method stub
return 2*3.14*dim;
}
public static void main(String[] args) {
Shape shape = new Circle(3.0);
System.out.println(shape.callAres());
System.out.println(shape.callPerimter());
}
}
需要注意的是：为实现的方法和空方法是不同的，
空方法是有函数体的，而为实现的方法是没有函数体的。
Shape类是一个抽象类，Circle继承了Shape。一个类在继承抽象类的时候必须实现他的所有的抽象方法，如果没有那么这个类也要申明为抽象类。
抽象类是不能实例化对象的，但可以定义一个抽象类的对象，并引用器非抽象子类的对象。
扫描二维码关注公众号，回复：
4230924 查看本文章
2.接口
interface是接口的关键字
接口是一种特殊的抽象类型，是对抽象类的进一步强化。
一般情况接口中的方法都是没有实现的，但是在jdk1.8以后可以出现实现的方法，需要使用default关键字。
接口的实现，使用implements关键字可以实现多个接口，接口之间用逗号隔开、
一个类实现一个接口时，需要实现接口中定义的所有没有方法体的方法。
在接口中只能定义常量，而且是public static final形式的。且必须要付出值。
例子：
public interface MyInterface {
public void add(int x,int y);
public void volume(int x,int y,int z);
}
public interface MultiInterface {
public static final double PI=3.1415;
public void callArea();
}
public class MyClass implements MyInterface {
public void add(int x, int y) {
// TODO Auto-generated method stub
System.out.println(x+y);
}
public void volume(int x, int y, int z) {
// TODO Auto-generated method stub
System.out.println(x+y+z);
}
public static void main(String[] args) {
MyInterface mi = new MyClass();
mi.add(3, 4);
mi.volume(1, 2,3);
}
}
public class MyClass2 implements MyInterface,MultiInterface{
public static void main(String[] args) {
// TODO Auto-generated method stub
MyClass2 myclass = new MyClass2();
myclass.callArea();
myclass.add(3,1);
myclass.volume(1, 2,3);
}
public void callArea() {
// TODO Auto-generated method stub
System.out.println("哈哈，例子没举好，尴尬！");
}
public void add(int x, int y) {
// TODO Auto-generated method stub
System.out.println(x+y);
}
public void volume(int x, int y, int z) {
// TODO Auto-generated method stub
System.out.println(x+y+z);
}
}
3.instanceof运算符：
<引用类型变量>instanceof<引用类型> 如果这个表达式为真（Boolean类型），左侧引用类型变量所引用的对象的实际类型是右侧给出的类型或者其子类的类型。
例子：
package com.dh.ch05;
//定义IBase接口
interface IBase {
public void print();
}
// 定义Derive类实现IBase接口
class Derive implements IBase {
int b;
public Derive(int b) {
this.b = b;
}
public void print() {
System.out.println("In Derive!");
}
}
// 定义Derive的子类Derive1
class Derive1 extends Derive {
int c;
public Derive1(int b, int c) {
super(b);
this.c = c;
}
public void print() {
System.out.println("In Derive1!");
}
}
public class InstanceofDemo {
// 判断对象类型
public static void typeof(Object obj) {
if (obj instanceof Derive) {
Derive derive = (Derive) obj;
derive.print();
} else if (obj instanceof Derive1) {
Derive1 derive1 = (Derive1) obj;
derive1.print();
}
}
public static void main(String[] args) {
IBase b1 = new Derive(4);
IBase b2 = new Derive1(4, 5);
System.out.print("b1 is ");
// 调用typeof()判断b1对象类型
typeof(b1);
System.out.print("b2 is ");
// 调用typeof()判断b2对象类型
typeof(b2);
}
}
b1 is In Derive!
b2 is In Derive1!4.对象的转换
4.1自动转换：
子类转换成父类（或者实现类转换成接口）时，装换可以自动完成。
4.2强制装换：
父类转换成子类（接口装换成实现类）时，必须使用强制转换。
5.内部类：
内部类分为成员内部类，局部内部类，静态内部类，匿名内部类。
5.1成员内部类的例子：
package com.dh.ch05;
public class OuterClass1 {
private int i = 10;
private int j = 20;
private static int count = 0;
public static void func1() {
}
public void func2() {
}
// 成员内部类中，可以访问外部类的所有成员
class InnerClass {
// 成员内部类中不允许定义静态变量
// static int inner_i = 100;
int j = 100; // 内部类和外部类的实例变量可以共存
int k = 1;
void innerFunc1() {
// 在内部类中访问内部类自己的变量直接用变量名
System.out.println("内部类中k值为：" + k);
System.out.println("内部类中j值为：" + j);
// 在内部类中访问内部类自己的变量也可以用this.变量名
System.out.println("内部类中j值为：" + this.j);
// 在内部类中访问外部类中与内部类同名的实例变量用 "外部类名.this.变量名"
System.out.println("外部类中j值为：" + OuterClass1.this.j);
// 如果内部类中没有与外部类同名的变量，则可以直接用变量名访问外部类变量
System.out.println("外部类中count值为：" + count);
// 直接访问外部类中的方法
func1();
func2();
}
}
public void func3() {
// 外部类的非静态方法访问成员内部类时，必须通过创建成员内部类的对象才能访问
InnerClass inner = new InnerClass();
inner.innerFunc1();
}
public static void main(String[] args) {
// 内部类的创建原则是，首先创建外部类对象，然后通过此对象创建内部类对象
OuterClass1 out = new OuterClass1();
OuterClass1.InnerClass outin1 = out.new InnerClass();
outin1.innerFunc1();
// 也可将创建代码合并在一块
OuterClass1.InnerClass outin2 = new OuterClass1().new InnerClass();
outin2.innerFunc1();
}
}
内部类中k值为：1
内部类中j值为：100
内部类中j值为：100
外部类中j值为：20
外部类中count值为：05.2局部内部类
package com.dh.ch05;
public class OuterClass2 {
private int s = 10;
private int k = 0;
public void func1() {
final int s = 20;
final int j = 1;
// 局部内部类
class InnerClass {
int s = 30;// 可以定义与外部类同名的变量
// static int m = 20;//不可以定义静态变量
void innerFunc() {
// 如果内部类没有与外部类同名的变量，在内部类中可以直接访问外部类的实例变量
System.out.println("外围类成员:"+k);
// 可以访问外部类的局部变量(即方法内的变量)，但是变量必须是final的
System.out.println("常量:"+j);
// 如果内部类中有与外部类同名的变量，直接用变量名访问的是内部类的变量
System.out.println("常量:"+s);
// 用this.变量名访问的也是内部类变量
System.out.println("常量:"+this.s);
// 用外部类名.this.内部类变量名访问的是外部类变量
System.out.println("外部类成员变量:"+OuterClass2.this.s);
}
}
new InnerClass().innerFunc();
}
public static void main(String[] args) {
// 访问局部内部类必须先定义外部类对象
OuterClass2 out = new OuterClass2();
out.func1();
}
}
外围类成员:0
常量:1
常量:30
常量:30
外部类成员变量:105.3静态内部类
package com.dh.ch05;
public class OuterClass3 {
private static int i = 1;
private int j = 10;
public static void func1() {
}
public void func2() {
}
// 静态内部类可以用public,protected,private修饰
static class InnerClass {
// 静态内部类中可以定义静态或者非静态的成员
static int inner_i = 100;
int inner_j = 200;
static void innerFunc1() {
// 静态内部类只能访问外部类的静态成员(包括静态变量和静态方法)
System.out.println("Outer.i=" + i);
func1();
}
void innerFunc2() {
// 静态内部类不能访问外部类的非静态成员(包括非静态变量和非静态方法)
// System.out.println("Outer.i"+j);
// func2();
}
}
public static void func3() {
// 外部类访问内部类的非静态成员:实例化内部类即可
InnerClass inner = new InnerClass();
inner.innerFunc2();
// 外部类访问内部类的静态成员：内部类.静态成员
System.out.println(InnerClass.inner_i);
InnerClass.innerFunc1();
}
public static void main(String[] args) {
new OuterClass3().func3();
// 静态内部类的对象可以直接生成
OuterClass3.InnerClass inner = new OuterClass3.InnerClass();
inner.innerFunc2();
}
}
100
Outer.i=1
下一篇是异常处理：