文章目录

Eclipse工具中java项目的工程结构静态代码块的书写格式静态代码块,构造代码块,构造方法的优先级static关键字的特点封装的概念private关键字的特点面向对象思想特点Eclipse中一些常用的快捷键继承的概念继承的好处继承的格式Java中的开发原则继承的特点继承中的注意事项继承中变量名相同的访问问题继承中子类构造方法访问父类构造方法的问题this和super的区别代码块的优先级问题有关方法重写和方法重载的区别多态的概念多态的前提条件:多态的成员访问特点:多态的好处:多态的弊端:多态的向下转型使用不当,程序出现异常:有关final关键字的特点:final修饰基本类型的变量和引用类型的区别冒泡排序思想冒泡排序核心代码选择排序思想选择排序核心代码抽象类的概念抽象类中抽象方法格式抽象类注意事项抽象类的本质抽象类的特点:abstract关键字不能和哪些关键字共存接口的概念接口的基本注意事项:接口的特点:抽象类和接口的区别:包的编译和运行同一个包下不同包下方法的形式参数问题:(引用类型)内部类的概念内部类注意事项内部类的分类:成员内部类的访问方法成员内部类中的修饰符:权限修饰符方法返回值问题(引用类型)成员内部类中的修饰符:权限修饰符方法返回值问题(引用类型)

Eclipse工具中java项目的工程结构

静态代码块的书写格式

static{//代码块内容}

静态代码块,构造代码块,构造方法的优先级

静态代码块>构造代码块>构造方法

***注意: 静态代码块只执行一次

static关键字的特点

1)被static修饰的,随着类的加载而加载

2)优先于对象存在

3)可以多个对象共享,共用

4)访问方式: 类名直接访问

**被static修饰的变量推荐访问方式: 类名.变量名

**被static修饰的方法推荐访问方式: 类名.方法名

封装的概念

将类的属性或者方法私有化,保证数据的安全性,对外提供公共的访问方法

private关键字的特点

private可以修饰变量,也可以修饰方法,只能在本类中访问

但是可以间接的通过公共的方法来访问

面向对象思想特点

1)更符合生活中思想行为习惯

2)将复杂的问题简单化

3)从执行者变为指挥者

Eclipse中一些常用的快捷键

alt+/:eclipse中神键 :通过缩写或者特定的单词可以提示代码

alt+sift+s–>c :创建无参构造方法

alt+shift+s–>o :创建有参构造方法

alt+shift+s–>r :提供公共的访问方法:setXXX(Xx xx)/getXXX

ctlr+d:删除某一行代码

ctrl+shift+o: 导包的快捷键

在创建对象的时候,new 类名() ; 使用ctrl+1/ctlr+2+l(字母),自动补全代码

继承的概念

将一些类的共性抽取出来,定义到一个独立的类中,让这个独立的类和这些类产生一种关系(extends 继承关系)

继承的好处

1)提高代码的复用性

2)提高代码的维护性

3)类与类产生的继承关系是多态的前提条件

继承的格式

class 父类名{}

class 子类名 extends 父类名{}

Java中的开发原则

低耦合,高内聚

耦合:类与类之间的关系,关系越少越好(在开发中:降低程序间的耦合性---->Spring框架:IOC思想:控制反转)

内聚:完成某个事情的能力,在一个类中能完成的,尽量在一个类中完成(执行力)

继承的特点

1)java中类与类的继承,只支持单继承,不支持多继承

2)支持多层继承

继承中的注意事项

1)子类继承父类,不能继承父类的私有成员(成员变量和成员方法)

因为被private修饰的外界访问不到,只能在本类中访问,但是可以通过公共的访问方法进行访问

2)子类继承父类,不能继承父类的构造方法,但是可以通过super关键字访问父类的构造方法

继承中变量名相同的访问问题

遵循"就近原则",从方法中最近的局部变量找起,如果没有从子类成员变量找,如果没有再从父类成员变量中寻找

继承中子类构造方法访问父类构造方法的问题

子类中的构造方法默认访问父类的无参构造方法,由于存在继承关系,创建子类对象,初始化子类的时候,可能用到父类的数据,因此需要先对父类初始化(执行父类构造方法),父类初始化完毕后,才是子类初始化,也就是分层初始化

**注意: 子类中的构造方法第一句话默认存在super();

​ super代表父类空间标识

注意事项:

子类的构造方法默认访问父类的无参,

那么如果父类中没有提供无参构造方法?会怎么办

会编译报错,因为父类有存在有参构造方法,系统不会提供无参的,又由于子类的所有构造

方法默认访问父类的无参,所以报错了!

如何解决呢?

1)手动给出父类的无参构造方法

2)可以让子类的所有构造方法,默认访问父类的有参

在子类的构造方法的第一句话:super(xxx)

子类中所有构造方法的一个只要能够让父类初始化即可!

3)通过子类的有参构造方法,访问this()本类的无参构造方法,在通过本类的无参构造方法

访问父类的有参构造(让父类先进行初始化)

this和super的区别

this:代表当前类的对象地址值引用

super:代表父类的空间标识(父类对象的地址值引用)

访问的区别

this.成员变量;访问的当前类的成员变量

super.成员变量;访问的父类的成员变量

this.成员方法名() ;访问的是否当前类的成员方法

super.成员方法名() ;访问的是父类的成员方法

this() :访问的是本类无参构造方法

this(xxx):访问的本类的有参构造方法

super():访问的是父类的无参构造方法

super(xxx):访问的父类的有参构造方法

代码块的优先级问题

静态代码块只执行一次,> 构造代码块 > 构造方法

运行程序的时候,jvm检查语法结构,有父子关系,先加载父类,再是子类,跟static相关 先进内存

2)继承中:分层初始化

优先让父类初始化(执行父类的构造方法)---->子类可能用到父类的数据,所以父类先初始化,

然后子类初始化(执行子类的构造方法)

有关方法重写和方法重载的区别

方法重写:

子类继承父类,子类出现了和父类一摸一样的方法,称为方法覆盖,复写/重写… (Override)

方法重载:

定义方法的时候,方法名相同,参数列表不同,与返回值无关 (Overload)

有的时候,为了保证数据的安全性,不想让子类将父类的方法覆盖掉—?

如何解决呢?

针对这种情况:Java提供一个关键字:final 表示最终的,终态的,无法更改的!

子类是不能覆盖父类的final修饰的方法

多态的概念

一个事物在不同时刻显示出的不同状态(在堆内存中的变化)

多态的前提条件:

1)必须存在继承关系 (继承的好处第三点)

2)要有方法重写 :

举例:动物的吃和睡的功能,只要看到具体的动物类:才能知道吃和睡的功能

3)需要存在:父类引用指向子类对象 (向上转型:使用的父类的东西,必须编译看左边!)

格式:父类名 对象名 = new 子类名() ;

多态的成员访问特点:

父类名 对象名 = new 子类名() ;

1)成员变量: 编译看左,运行看左边

2)成员方法:(非静态的):编译看左边,运行看右(因为存在子类覆盖父类的方法:方法重写)

3)静态的成员方法:编译看左,运行看左

(子类出现了和父类一摸一样的静态方法,静态方法跟类相关,不存在重写!,访问方式:类名.方法名())

4)构造方法:

由于存在继承关系,还需要分层初始化!

方法重写:指的是非静态方法!

多态的好处:

1)提高了代码的扩展性(由多态)

2)提高了代码的复用性,维护性(由继承关系保证)

多态的弊端:

不能够访问子类的特有功能!

如何解决呢?

方式1:可以创建子类具体类对象 :子类名 对象名 = new 子类名() ;

对象名.访问子类的自己的功能;

但是,不好,从内存角度考虑,在堆内存中产生一个内存空间(比较消耗内存空间!)

方式2:

多态的第三个条件:父类引用指向子类对象 (向上转型)

Fu f = new Zi() ;

想办法:将父类的引用强制转换为子类的引用(向下转型)

Zi z = (Zi)f;

好处:不需要重新new对象,在堆内存是比较节省内存空间的!

前提条件:要使用向下转型,必须先使用向上转型!

多态的向下转型使用不当,程序出现异常:

注意事项:

产生一个ClassCastException:运行时期异常(RuntimeException)的一种

使用向下转型的时候类型不匹配导致的!

有关final关键字的特点:

表示:最终的,无法更改(状态修饰符)

final修饰类,该类不能被继承!

final可以修饰成员变量,该变量此时是一个常量(常驻内存!)

自定义常量的时候:public static final 数据类型 变量名 = 初始化;

final可以修饰成员方法,该方法不能被重写

final修饰的变量:只能被赋值一次(它的值不能再被更改了!)

常量的分类:

字面值常量

自定义常量(final修饰的)

final修饰基本类型的变量和引用类型的区别

final修饰的基本数据类型

基本数据类型的变量:它的数据值不能再改变了(具体的数据值)

final修饰的引用数据类型,它的地址值不能再改变了(但是成员变量的值不影响!)

冒泡排序思想

从数组的第一个元素开始,两两比较,小的在前,大的在后,第一次比较结束,数组最大值出现在最大索引处

第一次有0个元素不进行比较

第二次有1个元素不进行比较

​ .

​ .

​ .

总共比较数组长度-1次

冒泡排序核心代码

for(int i=0;i<arr.length-1;i++){for(int j=0;j<arr.length-1-i;j++){if(arr[j]>arr[j+1]){int temp=arr[j];arr[j]=arr[j+1];arr[j+1]=temp;}}}

选择排序思想

用数组角标值为0的元素依次与后面的元素进行比较,将较小的值放在前面,较大的值放在后面,第一次比较完毕,数组最小值出现在了最小索引处,依次这样比较,就可以得到一个排序好的数组.

比较次数: 数组长度-1次

选择排序核心代码

for(int i=0;i<arr.length-1;i++){for(int j=i+1;j<arr.length;j++){if(arr[i]>arr[j]){int temp=arr[i];arr[i]=arr[j];arr[j]=temp;}}}

抽象类的概念

在一个类中,将某个功能给出声明(抽象方法),那么这个类就是抽象类

抽象类中抽象方法格式

抽象方法:

权限修饰符(public) abstract 返回值类型 方法名() ;

抽象类注意事项

1)如果一个类中,有抽象方法,那么该类一定是抽象类;抽象类中一定是抽象方法吗?,也可以有非抽象方法

2)抽象类如何实例化呢? 抽象类如何创建对象

抽象类不能直接实例化! ,通过具体的子类进行实例化

格式:

父类名 对象名 =new 子类名() ; 抽象类多态

3)抽象类的子类:

子类要么具体类,要么抽象类

子类是具体类,直接可以抽象类多态的形式实例化!

子类是抽象类,应该还要提供更最具体的子类,否则都无法实例化(没有意义!)

4)在抽象类中定义抽象方法的时候,那么抽象方法必须带上修饰符:abstract,不能省略!

抽象类的本质

强制子类必须完成的事情!

抽象类的特点:

1)成员变量:

既可以定义常量,也可以定义变量

2)成员方法:

即可定义抽象方法(必须要有abstract),也可以定义非抽象方法

3)构造方法:

还是继承关系,构造方法:对数据进行初始化---->分层初始化!

面试题:

有抽象方法的类一定是抽象类,

那么如果一个类中没有抽象方法,这个类可以不可以定义为抽象类呢?

可以,意义是什么?

意义:就是让当前类不能够直接实例化(实例化:创建对象)

那么如何实例化呢?

它会提供一个静态功能,返回值就是该类本身! (Java中一种设计模式)

举例:

Calendar:常用类 ---日历类是一个抽象类 (Java提供一个日历类)

在当前类提供了一个静态功能

public static Calendar getInstance()

abstract关键字不能和哪些关键字共存

不能和final一块使用:

final修饰成员方法:方法不能被重写,但是abstract修饰的方法,强制类完成的事情!

不能和private一块使用: private只能在类中访问!被static修饰的方法直接使用类名调用,---->但是抽象方法又需要让子类重写(静态方法算不上方法重写)方法重写注意事项:

子类继承父类,子类重写父类的方法必须保证访问权限足够大,使用public修饰(要么跟父类的修饰符保持一致)

接口的概念

描述一个事物的额外功能,本身不具备的

接口的基本注意事项:

Java提供接口来定义:

interface 接口名{

...

}

接口中的方法只能是抽象方法,不能有方法体

接口的命名规则:多个单词---->遵循"大驼峰命名法"

接口的实现类和接口是一种:implements 实现关系

将接口的实现类--->称为"接口的子实现类"

接口如何实例化呢?

接口不能直接实例化 ,

格式:

接口名 对象名 =new 子实现类名() ; //接口多态

接口的特点:

1)成员变量 只能有常量,用public static final 修饰,只能赋值一次

2)成员方法 只能有抽象方法,public abstract 返回值类型 方法名(); public abstract 可以省略

3)构造方法 没有构造方法

抽象类和接口的区别:

1)成员的区别

​ 抽象类: 成员变量既可以是变量也可以是常量

​ 成员方法既可以是抽象方法,也可以是非抽象方法

​ 抽象类有构造方法,进行初始化

​ 接口: 成员变量只能有常量 public static final修饰 只能赋值一次

​ 成员方法必须是抽象方法

​ 没有构造方法

2)关系的区别

​ 类与类: 继承关系,只支持单继承,可以多层继承

​ 类与接口: 实现关系,一个类继承一个父类的同时可以实现(implements)多个接口

​ 接口与接口: 继承关系,可以单继承,也可以多继承

3)设计模式的区别

​ 抽象类: 继承保证代码复用性,多态保证代码扩展性,是一种"is a"的关系

​ 接口: 是一种额外的功能,体现的是一种"like a"的关系

包的编译和运行

同一个包下

手动方式

1)先进入到HelloWorld.java文件所在目录中,使用javac 对这个java源文件进行编译,会产生

HelloWorld.class文件

2)手动方式创建对应包的目录

com

qianfeng

3)将1)---->编译后后HelloWorld.class文件放在2)中的子文件夹中4)运行:带上包进行运行java com.qianfeng.类名

​

​ 自动方式:

​ 1)针对源文件进行编译

​ javac -d(跟上参数) . java源文件 — >将class文件存储到指定包的下面

​ 2)直接运行即可

​ java 包名.类名 —>回车

不同包下

在不同包下的编译和运行:

1)将当前被导入的类:进行编译

进入到当前目录下面:

javac -d . Demo.java---->

Demo.class

2)进入到当目录下面javac -d . Test.java---->com.qianfengTest.class3)java com.qianfeng.Test; 运行 java 包名.类名

方法的形式参数问题:(引用类型)

如果方法的形式参数是一个引用类型

如果是具体类,需要传递该具体类的对象!

如果是抽象类类型,实际参数需要该抽象类的子类对象!

如果是接口,实际参数需要该接口子实现类对象!

内部类的概念

在一个类中定义了另一个类

在A类中定义一个B类,就B类称为A类的内部类;将A类称为B类外部类

内部类注意事项

内部类的成员直接可以访问外部类的成员包括私有!

外部类的成员访问成员内部类的成员的时候,不能直接访问,而要通过内部类对象访问

内部类的分类:

1)成员内部类:

在类 的成员位置定义的类

2)局部内部类:

在方法定义中定义的类(局部位置)

成员内部类的访问方法

1)当成员内部类的修饰符不是private的时候:

创建内部类对象的格式: 外部类名.内部类名 对象名=new 外部类名().new 内部类名();

2)当成员内部类的修饰符是private的时候

不能创建内部类对象,需要在外部类的成员方法中创建内部类对象,调用内部类的属性和功能,在测试类中创建

外部类对象,调用此方法,即可实现访问内部类

3)当成员内部类被static修饰的时候

创建内部类对象的格式: 外部类名.内部类名 对象名=new 外部类名.内部类名();

或者可以用 外部类名.内部类名.方法名() 的方式调用内部类的静态方法

成员内部类中的修饰符:

private:保证的数据安全性

static修饰: 有什么特点?

将静态的成员内部类看成是外部类的静态成员!

静态的成员内部类的成员方法(静态的还是非静态),只能访问外部类的静态成员!

权限修饰符

private 只能在本类中访问

默认修饰符 可以在本类中,同包的子类或者无关类中访问

protected 可以在本类,同包子类,无关类,不同包的子类中访问(不同包的无关类不可以访问)

public 均可以访问

方法返回值问题(引用类型)

方法返回值

是一个具体类类型:需要返回return 该具体类对象!

如果方法返回值是一个引用类型:

如果引用类型是一个抽象类:该方法需要返回该抽象类的子类对象!

如果方法返回是一个引用类型:

外部类对象,调用此方法,即可实现访问内部类

3)当成员内部类被static修饰的时候

创建内部类对象的格式: 外部类名.内部类名 对象名=new 外部类名.内部类名();

或者可以用 外部类名.内部类名.方法名() 的方式调用内部类的静态方法

成员内部类中的修饰符:

private:保证的数据安全性

static修饰: 有什么特点?

将静态的成员内部类看成是外部类的静态成员!

静态的成员内部类的成员方法(静态的还是非静态),只能访问外部类的静态成员!

权限修饰符

private 只能在本类中访问

默认修饰符 可以在本类中,同包的子类或者无关类中访问

protected 可以在本类,同包子类,无关类,不同包的子类中访问(不同包的无关类不可以访问)

public 均可以访问

方法返回值问题(引用类型)

方法返回值

是一个具体类类型:需要返回return 该具体类对象!

如果方法返回值是一个引用类型:

如果引用类型是一个抽象类:该方法需要返回该抽象类的子类对象!

如果方法返回是一个引用类型:

引用类型是一个接口类型:需要返回该接口的子实现类对象!