数组，继承，重载，多态，抽象，接口，GUI，内部类

设计层面的六大原则：

单一职责原则：

一个类只做一件事情，一个方法只做一件事，降低代码冗余，提高代码复用性。

不要把无关的事情放到方法中来完成。每个方法不要超过20行，10行为最佳。

最少知道原则：

尽量少公开方法或者属性，对外只公布接口。

里氏替换原则：

当基类被派生类替换时，功能不发生改变，所以在使用继承的时候，尽量不要发生重写。

用基类定义，用派生类实例化，利用派生类的实例替换基类。

接口隔离原则：

在不违背单一职责原则的情况下，确保一个接口只做一件事情，不要把无关的接口处理通过不同的参数，融入同一个接口。

依赖倒置原则：

高层模块（调用）不依赖底层（被调用）模块，依赖于抽象而不是具体。

开闭原则：（开放的接口越少越好）

通过访问修饰符进行访问控制，只开放必要的接口（方法，函数，行为，动作）给其他类调用，封装起来。

把改动比较频繁的接口，设为私有，开放出去一个相对稳定的接口。

对外提供查询，对内不提供修改；对外公布接口，对内隐藏具体方法实现。

 

 

 

Java注释

1./** */-类注释，可以通过javadoc来编译生成html文件

2./* */-多行注释，不可编译。

3.//-单行注释，不可编译。

java数组

数组的定义：

int[] array={1};

int[] newArray= new int[10];

String[] sArray= new String[6];

For-each语句 for类型与需要遍历队列一致的类型 变量名：队列名

for（string  s ：sArray）{

         System.out.println(s);

}

数组打印

System.out.println(array);//这样的写法是错误的！

System.out.println(Arrays.toString(array));//正确写法！

数据转换可使用Integer方法

int price = 200 * Integer.parseInt(pCount);（将其他数据类型转换为整型数据类型，使用integer方法下面的一些方法。）

If语句里面的判断两个等号是全等（栈和堆都相等），java里面可以使用.eauals()这个方法，判断数据是否相等。

三元表达式：

在表达式boolean-exp ? value0 : value1 中，如果“布尔表达式”的结果为true，就计算“value0”，而且这个计算结果也就是操作符最终产生的值。如果“布尔表达式”的结果为false，就计算“value1”，同样，它的结果也就成为了操作符最终产生的值。

int a=1;

int b=2;

int c= a>b?1:0;

 

Java面向对象程序语言设计

面相对象三个特点：

继承：传递性，可覆盖性，里氏替换原则，单一继承。

封装（打开应用的接口，关闭细节的实现）：属性，行为，访问修饰符，失血模型，开闭原则，单一职责。

多态：抽象类，接口，重载（静态多态性），动态多态性）（father f=new son();）

类与对象：

面向对象编程（object-oriented programming）

从类到对象：

1.       使用new关键字产生一个类的实例

2.       操作的全是对象。

从类到对象会经过4个步骤：

1.       加载

2.       连接

3.       初始化

4.       实例化

从类成为对象有几种方式：

a)         实例化—强制分配对象（消耗堆内存空间，实例的变量名消耗的栈内存空间has值，该值是地址，指向对应的堆。）

b)         反射

c)         反序列化

d)         克隆---产生一个新对象，与当前对象一模一样。

失血模型：只有属性，没有行为的类。（数据类）

富血模型：有属性和行为的类。

方法调用：

本类:

静态调用非静态通过对象直接调用。

其他情况都可以直接调用，或者使用this关键字调用。

不同类：

任何地方调用静态代码块可以直接通过类名，也可以通过对象调用。

其他的情况都需要通过对象调用。

Overload-重载

对于同类中的同名方法只要构成参数列表不一致（参数的数量、类型、不同类型的参数顺序的不一致），即形成重载。（只与参数列表有关，与返回值无关）

构造函数（又名构造器，构造函数，constructer）：

    是一种特殊的方法。主要用来在创建对象时初始化对象， 即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中。特别的一个类可以有多个构造函数 ，可根据其参数个数的不同或参数类型的不同来区分它们 即构造函数的重载。

    书写方式：（public+类名（参数列表）{}）。

    每一个构造函数默认存在一个无参构造函数。

    构造方法中调用其他重构的构造方法必须在第一行。

    **代码块：没有方法名，没有参数，在类实例化 的时候加载使用。（尽量使用构造方法，代替代码块）；

继承：

    继承就是子类（派生类）继承父类（超类，基类）的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

继承的关键字：

1.         在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的；

2.         This指代当前类实例。

3.         Super-指的是当前类的直接父类的实例。

4.         Super();指的是调用父类的无参构造。

类的继承格式：

    class 父类 {

    }

    class 子类 extends 父类 {

    }

在继承关系当中，非私有的方法和属性会被子类继承，但是私有的不可以被子类继承。

继承的特点：

1.         对于子类来说，子类拥有父类的所有非私有方法与属性，即包括（public,protected,default），修饰的所有方法和属性，排除不同包的情况下一些特殊情况。

2.         Java仅支持单根继承，意味着子类只有一个直接父类。

3.         在继承关系中，如果需要实例化子类，则需要实例化直接父类，也就是说需要实例化所有跟父类有继承关系的类。

4.         java所有类都继承了object类。（泛型）

5.         执行顺序：父类构造函数-子类构造函数-产生子类-产生子类的方法。

继承的优点：

1.         减少重复代码，降低代码冗余。

2.         如果父类已经有一些已有的方法和属性，那么子类继承父类时，可以直接调用。

3.         子类可以有自己独立的特殊方法，方便功能的扩展。

4.         方便功能的扩展。

重写：（override）

1.         为了实现子类方法时候，产生不同的效果。

2.         重写存在于继承关系当中。

3.         一定是子类重写父类的方法。

4.         重写的方法一定是和父类中被重写的方法结构一致（包括方法名和参数类型，参数数量）。

5.         访问权限只能扩大，不能缩小，即如果父类的方法是受保护的（protected），那么子类重写的方法可以是受保护的（protected），也可以是共有的（public）。

继承中注意事项：

成员变量的访问遵循：就近原则。

this访问本来的成员

super访问父类的成员

一个类的静态代码块，构造代码块，构造方法的执行流程

静态代码块==》构造代码块==》构造方法

静态内容是随着类的加载而加载，静态代码块的内容会优先执行。

类的初始化过程：

成员变量初始化==》默认初始化==》显示初始化==》构造方法初始化

子类父类初始化：（分层初始化）

先进行父类初始化，然后进行子类初始化。

Java 多态

多态的优点：

• 1. 消除类型之间的耦合关系
• 2. 可替换性
• 3. 可扩充性
• 4. 接口性
• 5. 灵活性
• 6. 简化性

多态的弊端：

    不能使用子类特有功能。

解决方案：

    创建子类对象的调用方法即可。（但是太占内存）

    把父类的引用强制转换为子类的引用。（向下转型）。

多态存在的三个必要条件

• 继承
• 要有方法的重写。（其实没有也可以，但是如果没有这个就没有意义！）
• 父类引用指向子类对象。

多态中成员的访问特点：

    f f=new s();

    成员变量：

        编译看左边，运行看左边。

    构造方法：

        创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。

    成员方法

        编译看左边，运行看右边。

    静态方法：

        编译看左边，运行看左边。

        （静态和类相关，算不上重写，所以，访问还是左边的）

    由于成员方法存在方法重写，所以它运行看右边。

多态中转型问题：

向上转型：从子到父，父类的引用只想子类的对象。

向下转型：从父到子，父类的引用转为子类的对象。

比如：

Parent p =new Child();

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。

多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

抽象与接口

抽象：

1.         抽象类的定义：所有使用关键字abstract的类都是抽象类。

2.         关于抽象类：

a)     抽象类中不一定有抽象方法 ，但是有抽象方法的类一定是抽象类。

b)         抽象类存在意义，用于被继承。

c)         抽象类有构造函数（用于子类访问父类数据的初始化），但不可以被直接实例化，抽象可以通过子类动态绑定实例化。

d)         抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。

e）抽象子类：

如果不想重写抽象方法，该子类是一个抽象类。

如果重写所有的抽象方法，这个时候子类是一个具体的类。

3.         抽象类的优点：

a)         从抽象方法来看，抽象方法要求必须被子类重写（规范子类行为）。

b)         从非抽象方法上看，提取子类共有行为。

接口：

1.         接口的定义：

a)         接口是一个特殊的抽象类，以interface修饰。

b)         当一个抽象类中全部都是抽象函数时，我们叫接口。

2.         接口的作用：

a)         规范实现类行为

3.         接口的定义规则：

a)         Public  interface 接口名（）；

b)         使用方式：在类名后使用implements关键字后加接口名，如：

                         i.              Public class A implements interB{};

4.         接口的使用

a)         接口的实现要么是抽象类，要么是普通类，普通类要求重写里面的所有的方法。

b)         接口可以多重继承。

c)         接口可以多重实现。

5.         接口的成员特点：

成员变量：只能是常量，并且是静态的。默认修饰符：public static final

构造方法：接口没有构造方法。

成员变量:只能是抽象方法。默认修饰符 ：public abstract。

类与接口之间的关系：

类与类：继承关系，只能单继承，可以多层继承。

类与接口：实现关系，可以单实现，也可以多实现。

接口与接口：继承关系，可以单继承，也可以多继承。

抽象类和接口的区别：

成员区别：

抽象类：

成员变量：变量和常量都可以。

构造方法：有

成员方法：可以抽象，也可以非抽象。

接口：

成员变量：只能是静态常量。

成员方法：只可以抽象。

关系区别：同类与接口关系。

设计理念的区别：

抽象类：被继承体现的是：“is a”的关系。定义的是该继承体系的共性功能。

接口：被实现体现的是：“like a”的关系。定义的是该继承体系的扩展功能。

内部类：

成员内部类修饰符：

    private 为了保证数据的安全性

    static 为了方便访问数据

        注意：静态内部类访问的外部类数据必须使用静态修饰。

    注意：内部类和外部类没有继承关系。

          通过外部类名限定this对象。

局部内部类：

    可以直接访问外部类成员

    在局部位置，可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类的功能。

    面试题：局部内部类访问局部变量必须使用final修饰，这是为什么呢？

            局部变量是随着方法的调用而调用，随着方法的调用完毕而消失。

            而堆内存的内容并不会立即消失。所以，我们加final修饰。

            加入final修饰后，这个变量就成了常量，既然是常量，

            你消失了，我在内存中存储的是后面的值，所以，我还有数据在使用。

匿名内部类：就是内部类的简化写法。

    前提：

        存在一个类或者接口（这里的类可以是具体类也可以是抽象类）

    格式：

        new 类名或者接口名（）{

            重写方法；

        }

    匿名内部类本质是什么呢？

        是一个继承了该类或者实现了该接口的子类匿名对象。（可以通过多态的方式调用内部类里面的方法）

JAVA GUI:

GUI：用户图形界面：graphic User Interface

java有两套gui解决方案：swing， awt

swing：完全基于纯Java代码实现，可以在不同的操作系统中运行。

awt:基于操作系统的图形接口，不具备有效移植性。