LEARNING
## 一、接口、继承、多态
1、类的继承
class Test2 extends Test{ //关键字extends标识继承关系
public Test2(){
super(); //关键字super调用父类构造方法和成员方法
super.doSomething(); //调用构造方法只能在构造方法中
}
public void doSomethingnew(){
//SomeStence
}
public void doSomething(){
//SomeNewStence
}
protected Test2 dolt(){
return new Test2();
}
}
重写：将父类的成员方法名称保留，重写实现内容，更改权限
重构：子、父类的成员方法返回值、方法名、参数类型以及个数完全相同，唯一不同的是方法实现内容
2、Object类 java.lang.O—bject——所有类的父类
①getCalss()——getClass().getName();
返回对象执行时的Class实例，然后使用getName()取得类的名称
②toString()——将一个对象返回为字符串形式，通常重写
public class ObjectInstance{
public String toString(){
return "在"+getClass().getName()+"类中重写toString()");
} //重写toString()方法使返回类名
public static void main(String [] args){
System.out.println(new ObjectInstance());
} //输出本类对象
}
③equals()——自定义类中比较引用地址会返回boolean变量，想要比较内容需要重写
3、对象类型转换
①向上转型——把子类对象赋值给父类类型的对象
比如：
平行四边形是一种四边形，因此属于四边形类的子类，当实例化平行四边形类对象时
可以使用 平行四边形 a = new 平行四边形();
等同于 四边形 a = new 平行四边形();
②向下转型——将父类对象强制转换为某子类对象（显式类型转换）
比如：Parallelogram p = (Parallelogram) q;
4、instanceof操作符——判断父类对象是否为子类对象实例
当程序中执行向下转型，若父类对象非子类对象的实例，发生ClassCastException错误
因此需要判断父类对象是否为子类对象实例。
myobject instanceof ExampleClass
比如：
Quadrangle q = new Quadrngle(); //实例化父类对象
if(q instanceof Parallelogram){ } //q是否属于四边形类的实例对象
返回值为boolean类型
5、方法重载
希望以不同方式实例化对象，则需要多个构造方法来完成，而构造方法名为类名，
为了让方法名相同而形参不同的构造方法同时存在，需要方法重载。
参数类型、个数、顺序不同均可构成重载。
定义不定长参数
返回值 方法名（参数数据类型…参数名） //相当于数组
也可与原方法构成重载关系。
6、多态
如：定义一个四边形类，处理继承该类的对象，根据向上原则，四边形类的对象作为方法的参数，在方法中作一些限定即可根据不同类四边形对象处理方法。
public class Quadrangle {
private Quadrangle[] qtest = new Quadrangle[6];
private int nextIndex = 0;
public void draw(Quadrangle q) {
if(nextIndex < qtest.length) {
qtest[nextIndex] = q;
System.out.println(nextIndex);
nextIndex++;
}
}
public static void main (String[] args){
Quadrangle q = new Quadrangle();
q.draw(new Square());
q.draw(new Parallelogram());
}
}
class Square extends Quadrangle{
public Square(){
System.out.println("正方形");
}
}
class Parallelogram extends Quadrangle{
public Parallelogram(){
System.out.println("平行四边形");
}
}
7、抽象类和接口
**①抽象类abstract：**一般将父类定义为抽象类，需要使用父类进行继承&多态处理
public abstract class Test{ //关键字abstract定义抽象类
abstract void testAbstract();
}
继承抽象方法的所有子类需要将抽象类中的抽象方法进行覆盖。
比如：将四边形类修改成抽象类，则其中的draw()方法设置为抽象方法，那么子类继承四边形类后，需要将draw()方法进行重写，无论需不需要都必须重写。
——因此出现①代码冗余 ②局限性大
**∴概念：**将draw()方法放入另一个类，需要的则继承，不需要的则不继承，但是一个子类只可继承一个父类，因此出现——接口。
②接口interface——其中所有方法都没有方法体
将draw()方法封装到一个接口中，使需要该方法的类实现这个接口，同时继承四边形类
public interface drawTest{
void draw(); //接口内的方法，省略abstract关键字
}
一个类实现一个接口可以使用implements关键字
public class Parallelogram extends Quadrangle
implements drawTest{
……//
}
使用接口需要覆盖接口中的方法
**接口的多重继承
class 类名 implements 接口1,接口2,...,接口n
interface intf1{
}interface intf2 extends intf1 {
}
## 二、类的高级特性
1、Java类包——管理类文件，解决类名冲突问题
①创建包 package 包名
》包冲突？包名使用创建者的Internet反序，不会冲突
②导入包
import java.lang.Math;
import java.lang.Math.*; //.*的作用是表示可以使用包中所有的类
import还可以导入静态成员
import static java.lang.Math.max; //静态成员方法
import static java.lang.System.out; //静态成员变量
2、final变量
final关键字一般用于变量声明，通常定义的量是常量。
也可用于修饰数组，未赋值的final成员变量为空白final。
编码规则：被final修饰的常量需要以大写字母+下划线表示
如：
private final int VALUE_1 = 9; //普通final值可以通过改变赋值改变
private static final VALUE_2 = 10; //用static声明的final值无法改变
3、final方法——final方法不可重写 ∴private
private final void test(){
...//
}
4、final类——final类不可继承
final class FinalClass{
...//
}
5、内部类
①成员内部类——在一个类中使用内部类
public class OuterClass{
private class InnerClass{
...//
}
}
内部类可以随意使用外部类的成员变量&方法，即使是private修饰
外部类不可直接访问内部类成员变量
- 内部类向上转型为接口 （Swing编程技术）
interface InnerInterface(){
public void f();
}
class OuterClass{
private class InnerClass implements InnerInterface{
InnerClass(String s){
System.out.println(s);
}
public void f(){
System.out.println("访问内部类的f()方法")；
}
}
∴如果有一个类继承了OutClass类，无法向下转型为内部类InnerClass，因此也无法访问f()方法，但是可以访问InnerIterface接口的f()方法。
- 使用this关键字获取内部类和外部类的引用
public class TheSameName{
private int x;
private class Inner {
private int x = 9;
public void doit(int_x){
x++; //调用形参x
this.x++; //调用内部类x
TheSameName.this.x++; //调用外部类x
}
②局部内部类——在方法中定义的内部类只能访问final类型的局部变量
Interface OutInterface2{
}
class OuterClass3{
public OuterInterface2 doit(final String x){
class InnerClass2 implements OuterInterface2{ //在doit()方法中定义内部类
InnerClass2(String s){
s = x;
System.out.println(s);
}
}
return new InnerClass2("doit");
}
}
③匿名内部类
class OuterClass4{
public OutInterface2 doit(){
return new OutInterface2(){
private int i = 0;
public int getValue(){
return i ;
}
}; //匿名内部类需要在大括号内编写
}
}
④静态内部类
public class StaticInnerClass{
int x = 100;
static class Inner{
void doitInner(){
//System.out.println("外部类"+x);
}
public class void main(String args[]){
System.out.println("a");
}
}
}
⑤内部类の继承
public class OutputInnerClass extends ClassA.ClassB{
public OutputInnerClass(ClassA a){
//继承内部类必须硬性给予这个类一个带参数的构造方法
a.super();
}
}
class ClassA{
class ClassB{
}
}
来源：CSDN
作者：DarryYee
链接：https://blog.csdn.net/DarryYee/article/details/88132156