Java_obj（一）

面试

引用类型变量的赋值：

引用类型变量存储的是对象的地址信息，相同类型的引用类型变量之间也是可以相互赋值。

引用类型变量之间的赋值不会创建新的对象，但有可能会使两个以上的引用指向同一个对象自。

2、null （空，即什么也没有。）

Cell c=new Cell();

c=null;//空，c不在指向对象

C.row=5;//错误，引用若为null，不能再.操作了。会产生NullPointerException空指针异常

引用类型变量，可以赋值为null。null的含义为“空”，表示还没有指向任何对象。

当一个引用的值为null的时候，如果通过引用访问对象成员变量或者调用方法是不合逻辑的，此时，会产生NullPointerException空指针异常。

3、new后，成员变量有默认值，

4、创建对象语法：

类名引用 =new类名（）；

其中：new 类名（）是在创建对象

因对象为数据，所有声明引用来指代数据

5、访问成员变量，访问方法

---------------通过点来操作，语法：引用.成员变量；引用.方法名（）；

6、方法的重载

方法签名：方法名和参数列表

一个类中，不可以有两个方法的签名完全相同。如果一个类的两个方法只是方法名相同而参数列表不同，是可以的。

7、构造方法

8、引用类型数组

方法的重载：

方法的签名，函数名相同，参数列表不一样。在同一个类里面，允许多个方法的名称相同，但参数列表不同，称之为方法的重载。//注意，签名只包括名称和参数，跟返回值没关系，所以要是只是返回值的类型不一样，但是方法名称和参数列表一样，这样的不叫方法的重载。

比如：class Aoo{

Void pay(){ }

Void pay(double d){ }

Void pay(String s1,String s2){ }

Int pay(){ }//错误的，返回值的不同不算是方法的重载。

}

再比如：

System.out.println();

System.out.println(“Helloworld”);

System.out.println(111);

System.out.println(5.55);//只是参数不一样。

9、

Java建议：

1个文件只包含1个类。

规定：Java中1个文件可以包含多个类。但是，public的类只能有1个，且必须跟文件名相同。

语法：

1.class-----------成员变量、方法

2.测试类-------main（）{创建对象}

编译器在编译时会根据签名来绑定调用不用的方法，我们可以把重载的方法看成是完成不同的方法，只不过恰好方法名相同而已。

1、构造方法：

构造方法常常用于给成员变量初始化；

构造方法与类同名，没有返回值类型。（void int 等类型都没有）

构造方法是在创建对象时，被自动调用的，不需要点调用。

若自己不写构造方法，则编译器默认给一个无参的构造。

若自己写了构造方法，则不在默认提供无参构造。

构造方法可以重载。

//1、创建了一个对象

//2、调构造

Student a=new Student();

this:

1、 this指代当前对象，谁调指的就是谁

class Cell{

int row；

int col;

Cell(int row, int col){

this.row=row;

this.coll=col;

}

void drop(){

row++;//其实前面有个默认的this即this.row++,当名字不冲突的时候一般不用写this

}

Main(){

Cell c=new Cell(5,4);//此时构造方法中的this就是c; c.row=5,c.col=4;

C.drop();//c.row++

System.out.println(c.row);

Cell cc=new Cell(8,2);

}

2、this用法：

this.成员变量--------访问成员变量

this.方法()-------------访问方法

this()---------------------调构造方法

例子：

class Cell{

int row;

int col;

Cell (int row,int col){

this.row=row;

this.col=col;

}

Cell(int n){

this(n,n);

}

Cell(){

this(0,0)；//调两个int型参数的构造，或者可以写成this（0），即先调用cell（0）----->然后有调用cell（0,0）

}

3、在类里面的方法都可以用this，只要方法里面用到了类中的成员变量都有this. ,有时候成员变量名和局部变量名不冲突时，this就可以省略不写。

二、数组

1、引用类型数组的定义

Cell [] cs=new Cell[4];//此时的new是在创建数组对象，而不是创建数组对象（因为创建对象得调构造方法）

2、引用类型数组的初始化

new之后，arr中每个元素都是0；

int [] arr=new int[4];

new之后，cs中每个元素都是Cell类型，默认值是null；引用类型的每个元素默认值都是null

Cell [ ] cs =new Cell[4];

Student[] ss=new Student[4];

例子：

int[] arr=new int[4];

arr[0]=5;

Cell[] cs=new Cell[4];//new 是在创建数组

cs[0] 为Cell类型,此时都是null

cs[0]= new Cell();//new 是在创建Cell对象

Cell[] cs=new Cell[4];//此时cs[0]=cs[1]=.......=null

则cs[0].row=5;//此时会报错，空指针异常，因为null不能点成员变量，应该先创建对象。

正确修改为：

Cell[] cs=new Cell[4];//new 是在创建数组

cs[0]= new Cell();//new 是在创建Cell对象

System.out.println(cs[0].row);

或者：先声明在初始化数组元素

1) Cell[] cs=new Cell[4];

cs[0]=new Cell();

cs[1]=new Cell(5,4);

2)Cell[] cells={

new Cell(),

new Cell(1),

new Cell(5,4),

new Cell(7,5)

};

3)Cell[ ] cells=new Cell[] {

new Cell(),

new Cell(1),

new Cell(5,4),

new Cell(7,5)

};

声明int[]类型的数组，名为arr,包含4个元素，每个元素，默认值为null，因为数组int []，是引用类型，所以默认值为null,

int[] [] as=new int[4][];//as为数组的数组，as包含4个元素，里面每一个元素都是int[]类型数组

as[0]默认值为null，

as[0]是int[]类型

as[0]=new int[2];//as[0]数组中有2个元素

as[1]=new int[4];

as[2]=new int[2];

as[3]=new int[5];

给as中第2个元素的第3个元素赋值为100

as[1][2]=100;

数组：

1、数组是引用类型；数组对象存在堆中；数组所声明的变量叫引用；

2、数组的类型可以是基本类型的数组，也可以是引用类型的数组；引用类型数组new之后，每一个元素默认初始值为null。

2017.02.07

任务：定义Tetris项目中的T类和J类并测试，每个方块由四个格组成。

分析：

1、先找对象，-----------7种图形对象；

2、抽类

class T{}

class J{}

class O{}

class S{}

class Z{}

class I{}

class L{}

3、设计类中的成员变量(特征)和方法(行为）

class T{//包含4个格

Cell[] cells;//对此成员变量赋初值，建议放在构造方法中

T（int row,int col）{//其实传的参数仅仅传个第一个cell构造,使T型出现的位置灵活。

Cells=new Cell[4];

cells[0]=new Cell(row,col);

cells[1]=new Cell(row,col+1);

cells[2]=new Cell(row,col+2);

cells[3]=new Cell(row+1,col+1);

}

void drop(){//下落一个

for(int i=0;i<cells.length;i++) cells[i].row++;

}

void moveLeft(){//左移一个

for(int i=0;i<cells.length;i++) cells[i].col- -;

}

void moveRight(){//右移一个

for(int i=0;i<cells.length;i++) cells[i].col++；

}

void print(){//输出4个格子的坐标

for(int i=0;i<cells.length;i++){

//System.out.println(cells[i].row+”,,,”+cells[i].col);

/* String s=cells[i].getCellInfo();

System.out.println(s);*/

System.out.println(cells[i].getCellInfo());

}

main(){

T t=new T(1,5);

T tt=new T(3,4);

}

同理：

class J{

Cell[] cells;

J(int row,int col){

cells=new Cell[4];

cells[0]=new Cell(row,col);

cells[1]=new Cell(row,col+1);

cells[2]=new Cell(row,col+2);

cells[3]=new Cell(row+1,col+2);

}

void drop(){//下落一个

for(int i=0;i<cells.length;i++) cells[i].row++;

}

void moveLeft(){//左移一个

for(int i=0;i<cells.length;i++) cells[i].col- -;

}

void moveRight(){//右移一个

for(int i=0;i<cells.length;i++) cells[i].col++；

}

class O{

Cell[] cells;

O(int row,int col){

cells=new Cell[4];

cells[0]=new Cell(row,col);

cells[1]=new Cell(row,col+1);

cells[2]=new Cell(row+1,col);

cells[3]=new Cell(row+1,col+1);

}

void drop(){//下落一个

for(int i=0;i<cells.length;i++) cells[i].row++;

}

void moveLeft(){//左移一个

for(int i=0;i<cells.length;i++) cells[i].col- -;

}

void moveRight(){//右移一个

for(int i=0;i<cells.length;i++) cells[i].col++；

}

继承：（在继承基础上达到多态）

注意：只要和main平级的方法都要前面加static哦！

对象内存管理：

有关堆的内容：

堆内存：凡是new出来的对象都在堆里面。即声明一个对象时，语句右边new那部分是放到堆里面的。包含其成员变量，并有初始值。

栈内存：接收对象的那个引用是在栈里面的，里面存的是对象的地址。

局部变量是放在方法里面的，没有默认值，必须自行设定初始值。成员变量是放在类里面方法外面的变量。有默认初始值，可以不显示初始化；

成员变量的生命周期：

访问对象需要依靠引用变量；

当一个对象没有任何引用时，被视为废弃的对象，属于被回收的范围。该对象中的所有成员变量也随之被回收；

成员变量的生命周期为：从对象在堆中创建开始到对象从堆中被回收结束。

Cell c=new Cell();

c=null;//不再指向刚分配的对象空间，成员变量失效

内存泄漏：对象不再使用时，没有及时的对其引用赋值为null造成的内存泄漏。只要存在有个引用在引用着对象，就不被视为废弃对象。所以，当确定某对象不再使用了，应该及时将其引用设置为null。

垃圾回收器（GC）（Garbage collection）：不定时回收没有引用指向的对象，回收过程透明，想快些调用System.gc()方法。

非堆-----栈（有时也称堆栈）：

Java中，调用一个方法，就给该方法分配一个“栈桢”，栈桢中存的就是所有的局部变量。方法调用结束，栈桢消失，局部变量跟着消失。

Cell c=new Cell();

C.add();

class Cell{

int add(int num1,int num2){

int num=num1+num2;

return num;

}}

1、栈：用于存储所有局部变量；

2、调用方法时，栈中分配该方法的栈桢，栈桢中包含参数及方法中声明的变量；统称为局部变量；方法执行结束，栈桢被清除，局部变量一并失效，被清除。

非堆--------方法区

存放的是.class文件内容（字节码），即类的相关信息。存储类的各种信息（包括方法及.class）。就是加载.class文件时，方法也一并加载过来。

注意：方法只有一份在方法区中装着,通过this区分是哪个对象在调用方法；而成员变量有一个对象就有一份；

继承：避免代码重复

通过extends关键字实现继承，子类继承父类后将具有本类的成员以及父类的成员；

在父类中包含所有子类公有的数据；

子类中包含子类所特有的数据；

Java不支持多继承；是单一继承，java继承有传递性；

Java规定，构造子类之前必须先构造父类；若自己不写super ;则在子类构造中默认添加super（）无参父类构造方法。来调用父类无参构造。并且super（）必须位于子类构造的第一句。

注意类和类要平齐，方法和方法要平齐；方法和方法要平齐；一个文件可以包含多个类，但是public类只能有一个并且还必须跟文件名一样；

一次判断不能得到最终结果用开关；

父类类型引用指向子类的对象---------------向上造型

向上造型：即父类型的引用指向子类的对象；能点出来什么看类型，跟对象无关；向上造型：让子类公用一种类型----------父类型

2017.02.08

2017.03.24

1.重写（覆盖）：发生在两个类中，并且是子父的关系，子类方法与父类方法签名（方法名和参数）相同时，我们说，子类重写了父类的方法。

2、当方法被重写时，调哪个看对象。对象，即new的谁就调谁的方法，即看new后面的类型。

3、子类可以重写（覆盖）继承自父类的方法，即方法名和参数列表与父类的方法相同，但方法的实现不同。

4、当子类对象的重写方法被调用时，（无论是通过子类的引用调用还是通过父类的引用调用）运行的是子类的重写后的版本。

5、子类在重写父类的方法时，可以通过super关键字调用父类的被重载的版本方法。

this :--------------------------------------------- 本类

this.成员变量

this.方法（）

this（）

Super:-------------------------------------------- 父类

Super.成员变量

Super.方法（）

Super（）

二、重写（override）和重载（overload）的区别-----------------------面试题：

重载：

在一个类中方法名相同，参数列表不同。（在编译的时候，根据参数的个数和类型来决定绑定哪个方法），在调用重载方法时，传的实参，是看等好左边的类型而不是new后面的类型（对象）

重写：

在两个类中，并且是子类和父类的关系，签名相同。（在程序运行时，根据对象的类型不同（而不是引用类型）而调用不同的版本）

三、编译和运行时的区别

编译时：----------------.java 到.class文件的过程。此时jvm还没有登场。内存（堆（放对象，以及它的成员变量），栈（放的是局部变量），方法区））没东西，没对象，只看语法对不对。

运行时：----------------jvm加载.class并运行.class的过程，此时，有对象了。内存是由jvm分配的。内存才有东西，才有对象。

四、重载时看类型，重写时看对象。

2017.03.25

一、包：解决类的命名冲突问题。但规定同一个包里面的文件（名）即，类名，不能重名。不同包里面的文件可以重名。其包名的时候建议所有字母小写，（package包名；），一旦使用的package指定了包名，类的全称应该是“包名.类名”。包名可以重叠。用点间隔。包名也可以有层次结构，在一个包中可以包含另外一个包。package包名1.包名2....包名n

建议模式：

域名反写项目名称模块名称

Com.inspur.Studentmanager.course.类名

Import：对类的全称进行声明。”import 包名. 类名” 声明之后，就可以直接使用类名来访问了。

全局限定名-----------------------包名+类名

同一个包中的不用import，不同包中才需要应用。

二、访问控制修饰符：

Private 修饰的成员变量和方法仅仅只能在本类中使用，

Public修饰的成员变量和方法可以在任何地方调用。Public修饰的内容是对外提供可以被调用的功能，需要相对稳定，private修饰的内容是对内实现的封装，如果“公开”会增加维护的成本。

默认访问控制只能被同包中的类来访问控制。即在成员变量和方法前不写访问控制符。

Protected修饰的成员变量和方法可以被子类及同一个包中的类使用。

Note：对于类来说，只能写public或者默认方式。变量和方法四个访问控制符都可以使用。

Protected和private可以用于修饰内部类。

写在方法里面的局部变量，使用访问修饰没有意义，应为，它的作用域只是在方法中。修饰符仅仅是指成员变量和方法的访问控制权限。

注意：同一个包里面的才可以直接用new来生成某类的对象。不同包中想引用某包中的类时，用import来声明某类。

子类不能拿过来父类中私有的东西。子类继承不了。单例模式就是把构造方法私有化。

单例模式--------------------------面试题

class Aoo{

private Aoo（）{

}

void show（）{

Aoo o=new Aoo（）；//同一个类中private变量或方法可用

}

class Boo{

void show（）{

Aoo o=new Aoo（）；//错误，private的方法只能在自己的那个类中使用。

}

三、static关键字

Static修饰成员变量；

在成员变量前面加static和不加完全不一样，存的地方也不一样。

在成员变量前面，不加static时，new一个对象，在堆中就有对象和他的成员变量，使用变量时，是引用点

加static后，该成员变量就不属于对象了。而是属于类的变量。通常可以通过类名来引用static成员。

凡是在方法区里面的东西都只有一份，所有对象公用这一份东西，包括：.class文件和类中的方法和类中的static修饰的成员变量，即类的变量，不是对象的成员变量了。

堆里面有个对象的类型，还有个对象的成员变量。某类声明了几个对象，其中就有几份。

栈中个有某对象的引用，里面是对象的栈指针，

实例化：创建对象的过程

实例：实际的例子

四、成员变量：

实例变量：不用static修饰的。属于对象，一个对象有一份。

静态变量：由static修饰的。属于类，所有对象公用这一份。可以对象点变量，但我们常常用类名点变量。即，凡是静态变量是不需要new对象的，因为他不属于对象，而是属于类。

class Hoo{

int a;//实例变量

static int b;//静态变量

Hoo(){

a++;

b++;

}

void show(){

System.out.println(a);

System.out.println(b);

}

什么时候用静态变量，什么时候用实例变量？

class Customer{//账户类

String customerName;//账户名称

String customerPwd;//账户密码

double poir;//利率

}

五、static修饰方法

在类的方法中，常常需要对对象的实例变量操作。

类的普通方法（非静态方法）,默认有个隐式的this（即默认有对象的）,实例变量和静态变量都可以使用。

类的静态方法，没有隐式的this的，（即没有对象），所以不能再静态方法中去引用非静态的变量，即实例变量。

class Cell{

int row;//属于对象---------------实例变量

int col;//属于对象---------------实例变量

Static int num;//属于类----------没有对象也可用

static void show（）{

row++;//错误的，要想使用就是只能自己new对象来使用实例变量

Cell c=new Cell();

C.row=5;//是没有意义的，在静态方法中你是不会创建另外一个对象去调用它的东西。

num++;//正确的

}

void drop(){

this.row++;

num++;//等价于this.num++

}

void moveLeft(){

this.col--;

}

小结：非静态方法：-------有隐式this

可以直接访问静态变量和实例变量，不能类点方法名访问，因为这样的话没有this了。必须由对象来访问。

静态方法：---------没有隐式this

只能直接访问静态变量。不能直接访问实例变量。由类点静态方法名来访问，

何时用静态方法，何时用非静态方法？

答：不需要访问实例变量时，就可以做成静态方法，若需要访问实例变量则写成非静态方法。普通方法用的比较多。Int d=p1.distance(p2)//默认还传递了个this参数，p1是this；静态方法，只与参数相关，与实例变量无关。Eg:Arrays.sort(arr);

六、static块

属于类的代码块，在类加载期间（.class文件放到方法区中）执行的代码块，注意类只被加载一次，生成第二个对象时，就不重新加载类了，只执行一次，可以用来在软件中加载静态资源。

先走的是方法区，加载的.class 文件，在走的堆，new的对象，所以，先执行的static，再有的对象。凡是static的只在方法，只有一份。

七、何时用静态代码块：

一般用于加载静态资源（图片，音频，视频）

八、总结，

静态变量，何时用？答：某数据被所有对象共用时，就用static来修饰。

Static修饰方法时：没有隐式的this传递，不能直接访问实例变量，何时用？方法的执行只与参数相关，与对象无关。通过类名直接访问。

Static块，属于类的块，在类加载期间执行，只执行一次，何时用？常用于加载静态资源，（图片，音频，视频）

九、final关键字--------------面试题

final关键字修饰成员变量，意为不可改变。

final修饰成员变量，两种方式初始化：

声明同时初始化；

构造函数中初始化；

final关键字也可以修饰局部变量，使用之前初始化即可。

Public class Emp{

Private final int no=100;//final变量声明时初始化 public void testFinal（）{

no=99;//编译错误，final的变量不可被改变

}

final修饰的方法，不可以重写。使一个方法不能被重写的意义在于：防止子类在定义新方法时造成的“不经意”重写。

final修饰的类是不能被继承的。使一个类不能被继承的意义在于：可以保护类不被继承修改，可以控制滥用继承对系统造成的危害。

总结：

final：1、修饰变量，变量不可以被修改。2、修饰方法，不可被重写。3、修饰类不可被继承。

十、static final常量（少加载过程，运行效率就高）

Static final修饰的成员变量称为常量，必须声明同时初始化，不可被改变。

Static final常量会在编译期被替换。常量的命名建议写成大写。

class Foo{

Public static final int NUM=100;//NUM存在方法区中，

}

十一、和main平齐的方法，用static修饰。凡是不是静态的方法必须是对象去点来调用。静态就不用了，直接类点静态方法，或者直接使用就好

2017 03-26

一、方法五要素：访问控制符，返回值类型，方法名，参数列表，方法体。

若方法不完整，则在其前面加上abstract即可。也就是抽象方法（不完整），抽象方法就是没有方法体的方法。意味着包含不完整的方法的类也不完整，则，该类也必须加abstract，即成为抽象类（不完整）

抽象类能创建对象吗？

答：不完整的类不能new对象。注意，Java不建议写空方法，而且方法体又没法写，所以不写空方法的话，就写成抽象方法（没有方法体的方法）（不完整）就可。那么包含抽象方法的类也是不完整的，应该写成抽象类。

1、抽象方法：（由abstract修饰）

只有方法的定义，没有方法体的。

2、抽象类：由abstract修饰。可以包含抽象方法，也可以包含普通方法。

3、包含抽象方法的类，必须是抽象类。因为有不完整的方法，意味他的类也是不完整的。类中没有抽象方法，也可以将类声明为抽象类。

4、抽象类不能被实例化（即不能new对象，但可以作为引用类型）。因为抽象类不完整。

5、抽象类一般需要被继承，

1）子类也声明为抽象类

2）子类重写抽象类中所有抽象方法（变不完整为完整。）----首选

6、类中没有抽象方法，也可以将类声明为抽象类。但仍不能实例化。

abstract class shape{//抽象类（不完整）

int c;//周长

abstract double area();//抽象方法（不完整）

}

class Square extends shape{//方形类

Square(double c){

this.c=c;//super.c=c;也可以

}

double area(){//重写

return 0.0625*c*c;

}

class circle extends shape{//圆形

circle (double c){

this.c=c;//super.c=c;也可以

}

double area(){//重写

return 0.0796*c*c;

}

Execite:

//声明一个数组，包含各种图形对象

//获取最大面积

a数组----1个圆形对象，1个方形对象，1个三角形对象；通过算法，求这3个对象的最大面积。

注意：是类型都能用数组

Shape s=new Shape();//错误的，因为抽象类型不能new shape对象

Shape s=new Circle();//正确，抽象类型shape可以做引用类型，new的对象是circle类型的。

Shape s=new Square();

Shape[] shapes=new Shape[3]//创建shape型数组，不是对象啊！

Shapes[0]=new Circle(1);

Shapes[1]=new square(1);//把一个子类型的对象，赋给了父类型的引用。

Int maxArea=shapes[0].area();//能点出来什么看类型。但是area（）重写了，调重写的时候，是看的是对象的重写的方法。

for（int i=1;i<shapes.length;i++）{

double area=shapes[i].area();

if(area>maxArea){

maxArea=area;

}

System.out.println(“maxArea=”+maxArea);

总结：

由abstract修饰的方法为抽象方法，抽象方法只有方法的定义，没有方法体实现，用一个分号结尾；

一个类中如果包含抽象方法，该类应该用abstract关键字声明为抽象类。

如果一个类继承了抽象类，必须重写其抽象方法（除非该类也声明为抽象类）

抽象类不能实例化，shape s1=new shape();是错误的

即使一个类中没有抽象方法，也可以将其定义为抽象类，同样，该类不可以实例化。

abstract和final关键字不可以同时用于修饰一个类，因为final关键字使得类不可继承，而abstract修饰的类如果不可以继承将没有任何意义。

意义：

抽象类的意义：为其子提供一个公共的类型，

封装子类中的重复内容（成员变量和方法）

定义有抽象方法，子类虽然有不同的实现，但该方法的定位是一致的。入口（方法名）是一样的（方法名，父类都能点出来）

二、接口

就是一个标准、一个规范，只要遵守了这个规范，就能干某件事儿。

语法：interface 接口名

接口中只能包含常量和抽象方法（没有方法体）。

接口不能被实例化，只需要指定标准，不需要实现。需要被子类实现的

接口是一个完全抽象的抽象类。没有一个方法可以是完整的。

子类实现接口，需要将所有抽象方法都实现。

类可以实现多个接口，用逗号分隔

若类又继承父类又实现接口。那么必须先继承后实现。

接口和接口之间可以继承。一个接口可以通过extends关键字继承另外一个接口。子接口继承了父接口中定义的所有方法。

接口可以看成是特殊的抽象类，即只包含有抽象方法的抽象类。

接口可以作为一种类型声明变量，一个接口类型的变量可以引用实现了该接口的类的对象，通过该变量可以调用该接口中定义的方法（具体的实现类提供了方法的实现。）

interface IInter{

public static final int NUM=5；//int NUM =5;默认前面有public static final

int numnum;//错误，因为，灭有赋值，即当成变量了。在interface中只有常量和抽象方法，所以，其前面省略了public static final，必须有个值。所以，接口中的访问方法权限是public的，不是protected的。所以它的子类重写接口中的方法时，必须加public，只能写public的来作为访问修饰符权限。

Public abstract void show（）；

Void sayHi();//默认public abstract省略。

}

实现

class Aoo implements IInter{//遵守标准

public void show(){

}

public void sayHi(){

}

重写：

方法名同，参数列表同；

子类的访问权限大于或等于父类的

接口和抽象类的区别--------------------面试题

案例：

银行卡系统。

想开一个工商银行（对象）

工商银行类--------遵守标准（工行接口）

1、制定标准---------工行接口

interface UnionPay{//银联接口

Void 存钱（）；

Void 取钱（）；

Void 改密码（）；

Void 查余额（）；

}

interface ICBC extends UnionPay{

Void 在线支付（）；

}

interface ABC extends UnionPay{//农行接口

Void 支付电话费（）；

}

2、做类---------------遵守标准

class ICBCImpl implements ICBC{//工行类
public void 存钱（）{}；

public void 取钱（）{}；

public void 改密码（）{}；

public void 查余额（）{}；

public void 在线支付（）{}；

}

class ABCImpl implements ABC{//农行类

}

3、main（）{

ICBCImpl icbc1=new ICBCImpl();//开了1个工行,可以点出所有的

Icbc1.存钱（）/取钱()/改密码（）/查余额()/在线支付（）

ICBC i=new ICBCImpl();//向上造型，只能点ICBC接口的方法

UnionPay icbc2=new ICBCImpl();//只能点UnionPay里面的方法。

}

二、多态、内部类、面向对象的汇总

接口和抽象类的区别--------------------面试题

多态：一个类型的引用在指向不同的对象时会有不同的实现。

同样一个对象，造型成不同的类型时，会有不同的功能。

举例：

cut（）方法---------------多态的

1、理发师----------------cut剪发

外科医生--------------cut开刀

演员------------------cut停止表演

（同样都是cut，不同人干的事儿不一样,多种形态）

(一个类型的引用在指向不同的对象时会有不同的实现。)

人 a=new 理发师（）；

人 b=new 外科医生（）；

人 c=new 演员（）；//向上造型

a.cut();//-----剪发

b.cut();//-----开刀

c.cut();//-----停止表演

abstract class 人{

abstract void Cut（）；

}

class 理发师 extends人{

void cut（）{

剪发

}

class 外科医生 extends人{

void cut（）{

开刀

}

class 演员 extends人{

void cut（）{

停止表演

}

2、我是多态的

讲师-------------------授课

儿子他妈---------------打他

老公的老婆--------------发火

（同样一个对象，造型成不同的类型时，会有不同的功能。）

讲师a=new Me();//向上造型

儿子妈妈 b=new Me();

老公的老婆 c=new Me();

a.授课（）;

b.打他（）；

c.揍他（）；

c.发火（）；//点出来什么，看的是类型。

Class Me implements 讲师，儿子妈妈，老公的老婆{

Public void 授课（）{}

Public void 打他（）{}

Public void 揍他（）{}

Public void 发火（）{}

}

interface 讲师{

void 授课（）；

}

interface 儿子妈妈{

void 打他（）；

}

interface 老公的老婆{

Void 揍他（）；

Void 发火（）；

}

总结：向上造型表现出多态的意义。

向上造型：

一个类的对象可以向上造型的类型有：

一个父类的类型

其实现的接口类型

Java编译器根据类型检查调用方法是否匹配。

父类 a=new 子类（）；//并没有强制类型转换，编译器认为父类的类型大

接口类 b=new 实现类（）；//实现类小，接口类类型大

达内职员 a=new 讲师（）；

强制转型：（大到小需强转）（转换类型看的是引用变量所指向的对象类型，而不是引用类型）

Eg:讲师 aa=(讲师)a;

aa.所有讲师类所具有的成员

可以通过强制转换将父类型变量转换为子类型变量，前提是该变量指向的对象确实是该子类类型。

也可通过强制转换将变量转换为某种接口类型，前提是该变量指向的对象确实实现了该接口。

如果在强制转换过程中出现违背上述两个前提，将会抛出ClassCastException（类转换异常）异常。

在强制转型中，为了避免出现ClassCastException,可以通过instanceof关键字判断某个引用指向的对象是否为指定类型。

达内职员 a=new 讲师（）；

if（a instanceof技术顾问）{--------true

技术顾问 aa=（技术顾问）a;

}

if（a instanceof项目经理）{---------false

项目经理 aa=（项目经理）a

}

总结：

1、多态的意义

1）同一类型的引用指向不同对象时，有不同的实现

2）同一个对象，造型为不同的类型时，有不同的功能。

2、强转：

1）父到子，前提：对象是子

2）转为接口前提：对象实现了该接口。

3）强转失败冒异常，通过instanceof解决。

语法：

引用 instanceof 数据类型-----------boolean

小结：

强转成功与否，看对象。

20170328

内部类：一个类可以定义在另一个类的内部，定义在类内部的类称之为Inner,其所在的类称之为Outer。

Inner定义在Outer的内部。通常只服务于Outer，对外部不具备可见性，Inner可以直接调用Outer的成员及方法（包括私有的）

Class Outer{

Private int time;

Class Inner{//内部类只在outer这里面用，别的地方不用时，通常写成内部类

Public void timeInc(){

Time++;

}

创建内部类对象：一般情况下，Inner对象会在Outer对象中创建（构造方法或其他方法）；Inner对象中会有一个隐式的引用(Outer.this)指向创建它的Outer类对象。

1、内部类：一个类只被一个类使用，对外不可见。Eg:宝宝是由妈妈来创造的

Class Mama{

Class Baby{

}

2、内部类对象通常自在外部类中被创建。

内部类中可以直接访问外部类的所有成员

Class Mama{//外部类

String name;

Mama(String name){

this.name=name;

}

Baby create(){

return new Baby();

}

Class Baby{//内部类

void mamaName(){

System.out.println(Mama.this.name);//注意，this代表当前对象，但是this.name ，this是Baby的对象，但Baby中没有name,所以，默认的不是this.name，而是，Mama.this.name;Mama.this是指Mama的当前对象，即当前外部类对象。

System.out.println(this.name);//错误，this指当前对象，当前是在Baby中，当前对象中没有name这个属性。

System.out.println(name);//对，因为默认是Mama.this

}

定义匿名内部类（没有名）：

1.何时用：

有一个类（子类或实现类），只需要创建一个对象，等这个对象创建好了之后，这个类就没有用了。

//如下为不使用匿名内部类的方式

interface Inter{

}

Class Aoo implements Inter{

放的是实现类的成员

}

main(){

Aoo o =new Aoo();

}

//如下为使用匿名内部类的方式

interface Inter{

}

main(){

//创建接口对象，错误的

Inter o=new Inter();//接口不能被实例化

//创建接口的实现类的对象--------实现类省略了

Inter o=new Inter(构造方法参数){

实现类的成员

};

}

//使用匿名内部类的方式

class Test{

main(){

//创建实现类的对象

Inter1 o=new Inter1(){

实现类的成员

};//正确

Inter2 o=new Inter2(){

};//错误，{}中尚未重写show()方法

//创建匿名内部类对象

Inter2 o=new Inter2(){

int num=2;

public void show(){

System.out.println(“HiHi”);

}

};

o.show();

}

interface Inter2{

void show();

}

interface Inter1{

}

作业：

1、内部类，匿名内部类--------实际应用中应用率不高，一般用于swing（窗口）的开发

class Mama{

Class Baby{

}

问：编译后生成几个.class文件

2、课后作业：

小结：

面向对象3大特征：

1、封装：

类-------------封装数据和方法（行为）（作为一个整体操作）

方法-----------封装功能的实现）（隐藏实现的细节）

访问修饰符------控制访问权限（保证数据的安全）

2、继承：

实现代码的重用；extends关键字

3、多态：多种形态，在继承的基础之上

使程序可维护性提高，可扩展

1）一个类型指向不同对象，可以有不同的实现

2）同一个对象造型时不同类型时，有不同的功能。

Java_obj（一）相关推荐

JDBC数据对象存储
一:将查询的结果生成对象,储存在数组中. 1 package day31; 2 3 import java.sql.Connection; 4 import java.sql.PreparedStat ...
SVD与SVD++的学习
SVD在推荐系统中的应用详解以及算法推导查看全文 http://www.taodudu.cc/news/show-6192782.html 相关文章: SVD算法和应用 SVD系列算法 opencv ...
android TV端如何读取微信网页版二维码显示生成一张图片
今天讲下TV端接二维码遇到的一些问题,由于是在微信平台申请的是以网站那种形式申请的,而不是服务号申请的,所以客户端显示的二维码是以网页的形式展现的,网页是用WebView加载实现的,但是我们的界面是这 ...
Unity安卓生成设备唯一id
目标:生成唯一id,重启后生成仍旧相同. 其实可以使用GAID等来源于其他SDK的唯一id,但是为了一个UUID而接入一些SDK,好像也不太对这里参考网上一些内容,通过设备相关信息,生成UUID.作 ...
【记录】Android关于WebView无/有图模式切换实现方案
需求描述:使用WebView加载一个链接,实现有图.无图模式之间的切换关于无图模式的2种理解阻塞图片的加载,网页上图片以一种灰底的形式存在完全实现图片的隐藏 1. 阻塞图片的加载这个就比较简单 ...

Java_obj（一）

Java_obj（一）相关推荐

最新文章

热门文章