------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流! -------
代码块
代码块:使用{}括起来的代码被称为代码块
局部代码块 :
在方法中出现;限定变量生命周期,及早释放,提高内存利用率
构造代码块:
多个构造方法方法中相同的代码存放到构造代码块中
每次调用构造方法,构造代码块都会执行,并且在构造方法前执行
静态代码块:
并加上static修饰;用于给类进行初始化,
在加载的时候就执行,并且值执行一次
代码块指的是使用"{}"括起来的一段代码,根据代码块存在的位置可以分为4种:
普通代码块;
构造代码块;
静态代码块;
同步代码块(线程同步的时候讲解)。
代码块里变量的作用域:
只在自己所在区域(前后的{})内有效;
普通代码块:
普通代码块就是直接定义在方法或语句中定义的代码块:
public void show(){
普通代码块
}
构造代码块:
直接写在类中的代码块:
优先于构造方法执行,每次实例化对象之前都会执行构造代码块。
Eg
<span style="font-size:18px;"><span style="font-size:18px;">public class Demo {
{
System.out.println("我是构造代码块");
}
public Demo(){
System.out.println("我是构造方法");
}
public static void main(String[] args) {
Demo d1 = new Demo();
Demo d2 = new Demo();
}
}
</span></span>
静态代码块
使用static修饰的构造代码块:
优先于主方法执行,优先于构造代码块执行,不管有创建多少对象,静态代码块只执行一次,可用于给静态变量赋值;
Eg:
<span style="font-size:18px;"><span style="font-size:18px;">public class Demo13 {
Demo13(){
System.out.println("我是构造方法!");
}
{
System.out.println("我是构造代码块!");//实例化对象的时候才会去调用!
}
static{
System.out.println("我是静态代码块!");
}
public static void main(String[] args) {
new Demo13();
new Demo13();//再次创建对象,证明无论创建几次对象,静态代码块都只执行一次
System.out.println("我是普通代码块!");
}
}
</span></span>
输出:
我是静态代码块!
我是构造代码块!
我是构造方法!
我是构造代码块!
我是构造方法!
我是普通代码块!
我的总结:这个例子非常好!
1、基本数据类型的包装类
引言:Java提倡的万物皆对象,但是数据类型的划分出现了基本数据类型和引用数据类型,那么我们怎么能把基本数据类型称为对象呢?
除了Integer和Character定义的名称和对应的基本类型差异大,其他六种都是将首字母大写就可以了。
Integer,Byte,Float,Double,Short,Long都是Number类的子类。(Number类后面讲);
Character和Boolean都是Object直接子类;
8个类都是final修饰的(不可被继承)。
2、基本数据类型和包装类相互转换
把基本数据类型 → 包装类:
通过对应包装类的构造方法实现
除了Character外,其他包装类都可以传入一个字符串参数构建包装类对象。
包装类 → 基本数据类型
包装类的实例方法xxxValue(); // xxx表示包装类对应的基本数据类型
<span style="font-size:18px;"><span style="font-size:18px;">boolean bool = false;
Boolean b2 = new Boolean(bool);
Integer i = new Integer(3);
int i2 = i.intValue();
Boolean b1 = new Boolean("TRue");//true
boolean b2 = b1.booleanValue();
Float f = new Float("3.14");//3.14
Integer i2 = new Integer("123s");//NumberFormatException
</span></span>
备注:
自动装箱&自动拆箱
jdk1.5开始出现的特性:
自动装箱:可把一个基本类型变量直接赋给对应的包装类对象或则Object对象
自动拆箱:允许把 包装类对象直接赋给对应的基本数据类型
Eg:
<span style="font-size:18px;"><span style="font-size:18px;">Integer i = 3;//装箱
int i2 = i;//拆箱
Object flag = new Boolean(false);
if(flag instanceof Boolean){
Boolean b = (Boolean)flag;
boolean b2 = b;
}
</span></span>
我的总结:对于基本数据类型和包装类之间的装换,我们可以直接的用,相互转换,因为java5之后的自动拆箱、装箱功能!即便不知道这个,其实使用中也不影响!
3、基本类型和String之间的转换
String → 基本类型,除了Character外所有的包装类提供parseXxx(String s)静态方法,用于把一个特定的字符串转换成基本类型变量;
基本类型 → String,String类有静态方法valueOf(),用于将基本类型的变量转换成String类型。
<span style="font-size:18px;"><span style="font-size:18px;">String str = "17";
int i = Integer.parseInt(str);//String --> 基本类型
String s1 = String.valueOf(i);//基本类型 --> String
</span></span>
我的总结:这个从后续的学习来看,用处不大,记住有这样的方法就行,查api!
4、Object类
所有类的公共父类,一旦一个类没有显示地继承一个类则其直接父类一定是Object。
一切数据类型都可用Object接收
class OOXX extends Object{}等价于class ooXX {}
常见方法
public boolean equals(Object obj):对象比较
public int hashCode():取得该对象的Hash码
public String toString():对象描述
Object类的 toString()方法:“对象的描述”
建议所有类都覆写此方法
直接打印输出对象时,会调用该对象的toString()方法。//可以不写出来
打印对象的时候,实际调用的对象实际指向的类的自我描述;
全限定类名+@+十六进制的hashCode值,等价于
全限定类名+@+IntegertoHexString(该对象.hashCode)
equals也是判断是否指向同一个对象
没有实际意义,有必要可以重写
public boolean equals(Object obj) {}
String 覆写了 Object的equals方法:只比较字符的序列是否相同
==用于判断两个变量是否相等
基本类型:
引用类型:必须指向同一个对象,才true
只能比较有父子或平级关系的两个对象
new String("1") == new String("1"); ?
5构造方法的私有化
有的时候我们为了避免外界创建某类的实例,就将某类的构造方法私有化,即将它的构造方法用private修饰:
外界如何用到?
提供get方法!不提供的话外界就没法创建对象!(对反射无效)
<span style="font-size:18px;"><span style="font-size:18px;">package reviewDemo;
class Stu{
//将构造方法私有化
private Stu(){
}
}
public class Demo15 {
public staticvoid main(String[] args) {
Stu s = new Stu();
}
}
</span></span>
6饿汉式和懒汉式
目的:整个应用中有且只有一个实例,所有指向该类型实例的引用都指向这个实例。
好比一个国家就只有一个皇帝(XXX),此时每个人叫的“皇帝”都是指叫的XXX本人;
常见单例模式类型:
饿汉式单例:直接将对象定义出来
懒汉式单例:只给出变量,并不将其初始化;
我的总结:
饿汉式,static修饰,随着类的加载而加载,会损耗性能,但是方法相对简单
懒汉式 第一次用的时候相对较慢,因为需要加载!线程,不安全!
<span style="font-size:18px;"><span style="font-size:18px;">package reviewDemo;
//单例模式
//饿汉式,直接把对象构造出来
class SingleDemo{
private static SingleDemos1 = new SingleDemo();
private SingleDemo(){
//提供私有化的构造方法,那么外界就不能构造对象了!
}
public static SingleDemo getS1() {
return s1;
}
}
//懒汉式,先定义,但是不创建对象
class SingleDemo2{
private static SingleDemo2s3 ;
private SingleDemo2(){
//提供私有化的构造方法,那么外界就不能构造对象了!
}
public static SingleDemo2 getS3() {//这是一个方法,返回值为创建的对象!
if(s3 ==null){
s3 = new SingleDemo2();
}//和饿汉式的区别,此时才来创建对象!
return s3;
}
}
public class Demo14 {
public staticvoid main(String[] args) {
SingleDemo s1 = SingleDemo.getS1();
SingleDemo s2 = SingleDemo.getS1();
SingleDemo2 s3 = SingleDemo2.getS3();
SingleDemo2 s4 = SingleDemo2.getS3();
System.out.println(s1 == s2);
System.out.println(s3 == s4);
}
}
</span></span>
输出:true true
备注:枚举更加安全些
<span style="font-size:18px;"><span style="font-size:18px;">package reviewDemo;
enum Stu{
jake;
//将构造方法私有化起来,反射也不能创建对象,安全
private Stu(){
}
}
public class Demo15 {
public staticvoid main(String[] args) {
}
}
</span></span>
7final关键字
① final可以修饰类,方法,变量。
② final修饰类不可以被继承,但是可以继承其他类。
③ final修饰的方法不可以被覆写,但可以覆写父类方法。
④ final修饰的变量称为常量,这些变量只能赋值一次。
⑤ 内部类在局部时,只可以访问被final修饰的局部变量。
⑥ final修饰的引用类型变量,表示该变量的引用不能变,而不是该变量的值不能变;
<span style="font-size:18px;"><span style="font-size:18px;">package reviewDemo;
final class Name{
}
class NewName extendsName{//ERROR,报错,因为Name有final修饰
}
public class Demo15 {
public staticvoid main(String[] args) {
}
}
</span></span>
8抽象类
抽象类:包含抽象方法的类,就是抽象类。 需要使用关键字 abstract修饰
抽象方法:只有方法声明,没有方法体, 需要使用关键字 abstract修饰
抽象类特点
1:抽象类和抽象方法必须用abstract关键字修饰
格式
abstract class 类名 {}
public abstract void eat();
2:抽象类不一定有抽象方法,有抽象方法的类一定是抽象类
3:抽象类不能实例化
那么,抽象类如何实例化呢?
按照多态的方式,由具体的子类实例化。
其实这也是多态的一种,抽象类多态。
4:抽象类的子类
要么是抽象类
要么重写抽象类中的所有抽象方法
注意:想创建对象,必须要将所有的抽象方法实现,才能创建对象
抽象类的成员特点:
成员变量
可以是变量
也可以是常量
构造方法
有构造方法,但是不能实例化
那么,构造方法的作用是什么呢?
用于子类访问父类数据的初始化
成员方法
可以有抽象方法 限定子类必须完成某些动作
也可以有非抽象方法 提高代码服用性
abstract不能和哪些关键字共存
private 冲突
final 冲突
static 无意义
当编写一个类时,我们往往会为该类定义一些方法,这些方法是用来描述该类的行为方式,那么这些方法都有具体的方法体。
但是有的时候,某个父类只是知道子类应该包含怎么样的方法,但是无法准确知道子类如何实现这些方法。
抽象方法的定义:通过abstract关键字来修饰的类称为抽象类;
我的总结:
抽象类用private修饰,里面可以有用private修饰的方法(没有方法体),强制子类进行覆写;
可以理解为:具有某些公共方法的一个总结类。
可以定义被abstract修饰的抽象方法
抽象方法只有返回类型和方法签名,没有方法体。
备注:
抽象类可以含有普通方法
抽象类不能创建实例对象(不能new)
需要子类覆盖掉所有的抽象方法后才可以创建子类对象,否则子类也必须作为抽象类
列举常见的几个抽象类:
流的四个基本父类
InputStream,OutputStream,Reader,Writer
我的总结:
抽象类是类的一种特殊情况:据有类的一切特点,但是不能实例化;一般的都得带有抽象方法。
抽象类不可以实例化,有时看到的近似实例化是多态机制的体现,并不是真正的实例化。
Eg:
Socket s = new Socket();
OutputStream os = s.getOutputStream();
左边是OutputStream类型变量的声明,右边是获取抽象类OutputStream的一个实例对象!
<span style="font-size:18px;"><span style="font-size:18px;">Socket s = new Socket();
OutputStream os = s.getOutputStream();
左边是OutputStream类型变量的声明,右边是获取抽象类OutputStream的一个实例对象!
package testDemo2;
abstract class Person{
}
class Student extends Person{
}
public class Demo2 {
public staticvoid main(String[] args) {
Person p =new Student();//体现的是多态,父类声明实例化子类对象。而不是抽象类实例化
}
}
</span></span>
9abstract方法
分析事物时,发现了共性内容,就出现向上抽取。会有这样一种特殊情况,就是功能声明相同,但功能主体不同。
那么这时也可以抽取,但只抽取方法声明,不抽取方法主体。那么此方法就是一个抽象方法。
abstract [非private访问修饰符]返回值类型 方法名称(参数列表);
抽象方法要存放在抽象类中。
抽象方法也可以存在于接口中
Eg:
<span style="font-size:18px;"><span style="font-size:18px;">package reviewDemo;
abstract class Person3{
abstract void show();
abstract void inof();
void turn(){
}
}
class NewP extends Person3{
@Override
void show() {
}
@Override
void inof() {
}
//不覆写的话会报错
}
public class Demo15 {
public staticvoid main(String[] args) {
//new Person3();报错!因为抽象类不可以实例化
}
}
</span></span>
10抽象类的体现-模板模式
抽象类是多个具体子类抽象出来的父类,具有高层次的抽象性;以该抽象类作为子类的模板可以避免子类设计的随意性;
抽象类的体现主要就是模板模式设计,抽象类作为多个子类的通用模板,子类在抽象类的基础上进行拓展,但是子类在总体上大致保留抽象类的行为方式;
编写一个抽象父类,该父类提供了多个子类的通用方法,并把一个或多个抽象方法留给子类去实现,这就是模板设计模式;
模板模式应用的简单规则:
1.抽象父类可以只定义需要使用的某些方法,其余留给子类去实现;
2.父类提供的方法只是定义了一个通用算法,其实现必须依赖子类的辅助;
我的总结:
如果父类的方法不想被子类覆写,那么可以在前面加上final关键字修饰。
Eg:
package reviewDemo;
//模板模式
//抽象类中包含很多的抽象方法,子类必须去覆写!
<span style="font-size:18px;"><span style="font-size:18px;">abstract class Method{
abstract double mul();//返回值类型如果是void的话,下面报错,因为没有返回值,无法引用!
abstract double divid();
void show(){
System.out.println("面积是:"+mul());//周长
System.out.println("面积是:"+divid());//面积
}
}
class Square extends Method{
double d;
public Square(double d) {
super();
this.d = d;
}
@Override
double mul() {
return d *d;
}
@Override
double divid() {
return 4 * d;
}
}
class Cirle extends Method{
double r;
public Cirle(double r) {
super();
this.r = r;
}
@Override
double mul() {
return 2 * 3.14 * r;
}
@Override
double divid() {
return 3.14 * r *r;
}
}
public class Demo16 {
public staticvoid main(String[] args) {
Square s = new Square(5);
s.show();
Cirle c = new Cirle(4);
c.show();
}
}
</span></span>
11接口(interface)
接口:
接口特点
接口用关键字interface表示
格式:interface 接口名 {}
类实现接口用implements表示
格式:class 类名 implements 接口名 {}
接口不能实例化
那么,接口如何实例化呢?
按照多态的方式,由具体的子类实例化。
其实这也是多态的一种,接口多态。
接口的子类
要么是抽象类
要么重写接口中的所有抽象方法
接口成员特点
成员变量
只能是常量
默认修饰符 public static final
构造方法
没有,因为接口主要是扩展功能的,而没有具体存在
成员方法
只能是抽象方法
默认修饰符 public abstract
类与类关系:
继承关系,只能单继承,但是可以多层继承
类与接口关系:
实现关系,可以单实现,也可以多实现
还可以在继承一个类的同时实现多个接口
接口与接口关系:
继承关系,可以单继承,也可以多继承
抽象类和接口的区别?
成员区别
抽象类
变量,常量
抽象方法
非抽象方法
接口
常量
抽象方法
关系区别
类与类
继承,单继承
类与接口
实现,单实现,多实现
接口与接口
继承,单继承,多继承
设计理念区别
抽象类 被继承体现的是:”is a”的关系。共性功能
接口 被实现体现的是:”like a”的关系。扩展功能
引入:抽象类是从多个类中抽象出来的模板,若要将这种抽象进行得更彻底,就得用到一种特殊的“抽象类”→ 接口;
例子:
生活中听说过的USB接口其实并不是我们所看到的那些插槽,而是那些插槽所遵循的一种规范;而我们看到的那些插槽是根据USB规范设计出来的实例而已,也就说插槽是USB的实例;
对应不同型号的USB设备而言,他们各自的USB插槽都需要遵循一个规范,遵守这个规范就可以保证插入插槽的设备能与主板正常通信;
对于同一种型号的主板上的多个USB插槽,他们有相同的数据交换方式,相同的实现细节,可认为他们都是同一个类的不同实例
我的总结:
接口只定义了类应当遵循的规范,却不关心这些类的内部数据和其方法内的实现细节.
接口只规定了这些类里必须提供的方法;从而分离了规范和实现.增强了系统的可拓展性和维护性;
使用接口的好处,拓展性,维护性更好,所以我们在开发中会经常用到接口.(相当于定义了一种标准)
接口,类,对象示意图
12interface定义
接口定义一种规范,规定一个类必须做什么,但它不管如何具体去做;
[修饰符] interface接口名extends父接口1,父接口2....
没有构造方法,不能实例化;
接口只能继承接口,不能继承类
接口里没有普通方法,方法全是抽象的;
接口里的方法默认修饰符是public abstract;
接口里的字段全是全局常量,默认修饰符是public static final;
接口里的成员包括(主要是前两个):
全局常量
公共的抽象方法
内部类(包括内部类,内部接口,内部枚举类);
我的总结:
接口没有构造方法,不能实例化!
接口里的方法全部是抽象的,没有普通方法,有默认的修饰符public abstract,必须全部覆写!
13接口
格式:public class SubImpl extends Super implements IA,IB
接口可以多继承,但是只能继承接口,不能继承类。
实现接口(支持多实现)
[修饰符] class类名implements接口1,接口2...
接口的实现必须在 extends 之后;
实现接口的方法必须是 public 类型
接口不能创建实例,但是可以声明引用类型的变量。
此时,引用类型的变量必须指向到其实现类对象。
IStudent s = new String();//
IStudent s = new StudentImpl();//
接口与类之间的关系:
实现关系或者说是继承关系.
可以说类实现了接口的方法,也可以说类继承了接口的方法,不同情况下不同的理解!
14面向接口编程之制定标准和简单工厂模式
制定一个标准,让别人去实现或者说满足它!
Eg:
interface USB{//定义USB标准
void useUSB();//USB有使用USB的行为
}
简单工厂模式
构建一个工厂出来,在里面进行生产,用的时候直接拿
我的总结:
好处:屏蔽不同子类实现的差异,提高代码的可拓展性和可维护性;
<span style="font-size:18px;"><span style="font-size:18px;"><pre class="java" name="code">package reviewDemo;
//简单工厂模式
interface Phone{//制定标准,都要实现send()方法
public void send();
}
class Iphone implements Phone{
@Override
public void send() {
System.out.println("Iphone手机在发短信");
}
}
class AndroidPhone implements Phone{
@Override
public void send() {
System.out.println("AndroidPhone手机在发短信");
}
}
class MyPhone implements Phone{
@Override
public void send() {
System.out.println("MyPhone手机在发短信");
}
}
class Factory{
public staticvoid show(String type){//传入参数,根据不同的类型个性化定制
if(type.equals("")){//为空的情况,不用往下执行
System.out.println("对不起,类型为空!,请重新输入!");
return;
}
Phone p = null;
if("Iphone".equals(type)){//判断类型
p = new Iphone();
}elseif("AndroidPhone".equals(type)){
p = new AndroidPhone();
}else{
p = new MyPhone();
}
p.send();
}
}
public class FactoryDemo17 {
public staticvoid main(String[] args) {
new Factory().show("Iphone");//调用方法
new Factory().show("AndroidPhone");
new Factory().show("MyPhone");
new Factory().show("YourPhone");
new Factory().show("");
}
}
</span></span>
输出:
Iphone手机在发短信
AndroidPhone手机在发短信
MyPhone手机在发短信
MyPhone手机在发短信
对不起,类型为空!
15面向接口编程之适配器模式
使用一个现成的类,但是它的接口不完全符合你的需求,我只想要它其中的一个方法,不想覆写其他的方法。
比如,窗体有变大,变小,关闭的行为,但是我现在只需要关闭行为;
<span style="font-size:18px;"><span style="font-size:18px;">package reviewDemo;
//适配器模式:只想用其中的某一个方法,用适配器作为中间的过渡
interface Windows{
void max();
void min();
void close();
}
//适配器模式,实现接口所有的方法,但是不写方法体!
class AdapterWindows implements Windows{
@Override
public void max() {
}
@Override
public void min() {
}
@Override
public void close() {
}
}
class MyWindows extends AdapterWindows{
//覆写父类的方法
public void close(){
System.out.println("这个实现的是关闭功能!");
}
}
public class Demo17 {
public staticvoid main(String[] args) {
new MyWindows().close();
}
}
</span></span>
16内部类:
把类定义在其他类的内部,这个类就被称为内部类。
class Outer{
class Inner{}//内部类
}
内部类的访问特点:
内部类可以直接访问外部类的成员,包括私有。
外部类要访问内部类的成员,必须创建对象。
内部类的分类:
成员内部类: 类中方法外
局部内部类: 方法内
成员内部类的使用
格式:
外部类名.内部类名 对象名 = new 外部类名().new 内部类名();
成员内部类的修饰符:
private: 提高安全性
static : 方便内部类的访问
局部内部类访问局部变量
必须被final修饰?
为什么呢?
因为局部变量会随着方法的调用完毕而消失,
这个时候,局部对象并没有立马从堆内存中消失,还要使用那个变量。
为了让数据还能继续被使用,就用fianl修饰,
这样,在堆内存里面存储的其实是一个常量值。
通过反编译工具可以看一下
匿名内部类,就是没有名字的内部类,它是内部类的简化写法。
前提:存在一个类或者接口
这里的类可以是具体类也可以是抽象类。
格式:
new 类名或者接口名() {
重写方法;
};
本质:
是一个继承了类或者实现了接口的子类匿名对象
匿名内部类:
理解为继承了一个类或者是实现了一个接口的子类,
并且完成了子类对象的创建,
同时子类对象没有名字
17形式参数和返回值问题
形式参数:
基本类型:
引用类型:
具体类 : 参数列表中要接收的是,具体类的实例对象
抽象类 : 参数列表中要接收的是,子类的实例对象
接口 : 参数列表中要接收的是,实现接口的类的实例对象
返回值:
基本类型:
引用类型:
具体类 : 返回结果是,具体类的实例对象
抽象类 :返回结果是,子类的实例对象
接口 :返回结果是,实现接口的类的实例对象
(了解)链式编程
new Outer().method().show();
每一次方法调用完毕后,都会返回一个对象,
用返回的对象继续调用方法,再返回对象,再调用方法....
18包(package):
包 可以理解为 就是文件夹
包 是用来存储多个.class类的
包 对类进行分类管理
包的格式:
package 包名;
多级包之间,使用.分隔
包的划分:
举例:
学生的增加,删除,修改,查询
老师的增加,删除,修改,查询
以及以后可能出现的其他的类的增加,删除,修改,查询
基本的划分:按照模块和功能分。
高级的划分:就业班做项目的时候你就能看到了。
按照模块:
cn.itcast.teacher
AddTeacher
DeleteTeacher
UpdateTeacher
FindTeacher
cn.itcast.student
AddStudent
DeletetStudent
UpdateStudent
FindStudent
按照功能:
cn.itcast.add
AddTeacher
AddStudent
cn.itcast.delete
DeleteTeacher
DeletetStudent
cn.itcast.update
UpdateTeacher
UpdateStudent
cn.itcast.find
FindTeacher
FindStudent
-----------------------------------
注意事项:
package语句必须是程序的第一条可执行的代码
package语句在一个java文件中只能有一个
如果没有package,默认表示无包名
带有包的Java程序如何编译运行:
1:手动
a: 编译java文件,产生class文件
b: 创建包所对应的多层文件夹,把class文件放到最低层文件夹中
c: 运行 java 包名.类名方式访问
2: 自动创建包
a: 编译java文件,产生对应的包,把class文件放入包的最底层
javac -d . 文件名.java
b: 运行 java 包名.类名方式访问
(了解)同包下类之间的访问:
导包格式
import 包名.类名;
import 包名.*;//不建议
注意:
这种方式导入是到类的名称。
package,import,class有没有顺序关系(面试题)
package --> import --> class
在一个java文件中,只能有一个package
可以有多个import
可以有多个class,通常一个java文件中对应一个类
19四种权限修饰符:
当前类中 同一个包下(子类和其他类) 不同包下的子类 在不同包下的其他类
(了解)类及其组成可以用的修饰符:
权限修饰符: private 默认 protected public
状态修饰符: static final
抽象抽象符: abstract
类:
权限修饰符: 默认 public
状态修饰符: final
抽象抽象符: abstract
最常用的就是 public
成员变量:
权限修饰符: private 默认 protected public
状态修饰符: static final
最常用的就是 private
构造方法:
权限修饰符: private 默认 protected public
最常用的就是 public
成员方法:
权限修饰符: private 默认 protected public
状态修饰符: static final
抽象抽象符: abstract
最常用的就是 public