---------------------- android培训、java培训、期待与您交流! ----------------------
课程 名称 格式 什么时候执行 给谁初始化
0508 构造函数 函数名() 对象一建立就会调用与 给对应对象初始化
之对应的构造函数
0509 构造代码块 {执行语句} 对象一建立就运行,而 给对象初始化
且优先于构造函数执行。
0606 静态代码块 static{执行语句} 随着类的加载而执行, 给类初始化
只执行一次。
*******执行构造代码块与成员变量显示初始化******
**********(代码中谁在前面谁就先执行)*********
类是继承,java只有单继承
接口是实现,java可以多实现,即可以实现多个接口(接口可以多继承)
成员变量和局部变量作用范围
成员变量作用范围:成员变量作用于整个类中。
局部变量作用范围:作用于函数中,或者语句中。
在内存中的位置:
成员变量:在堆内存中,因为对象的存在才在内存中存在。
局部变量:存在栈内存中。
这两句:
Car c=new Car();
c.num=5;
写成匿名对象:
new Car().num=5;
匿名对象调用属性无意义,调用方法有意义。
匿名对象使用方式一:当对对象的方法只调用一次,可以用匿名对象来完成,这样写比较简化。
如果对一个对象进行多个成员调用,必须给这个对象起个名字。
匿名对象使用方式二:可以将匿名对象作为实际参数进行传递。
用java操作缓存时才设计到强引用,弱引用,虚引用
注意:私有仅仅是封装的一种表现形式。
成员变量都有默认值,在堆中
局部变量必须初始化,不初始化不能用,在栈中
构造函数写法特点:1.函数名与类名相同,2.不用定义返回值类型,3.不可以写return语句。
例:
class Person
{
Person()
{
构造函数执行语句;
}
}
作用:对象进行初始化。
注意:默认构造函数的特点,多个构造函数是以重载的形式存在的。
1、构造函数要与类同名(void是返回值不确定,构造函数是不需要返回值)
2、对象一建立就会调用与之对应的构造函数。
3、构造函数的作用:可以用于给对象进行初始化。
4、当一个类中没有定义构造函数时,系统会默认给该类加入一个空参数的构造函数
5、当在类中自定义了构造函数后,构造函数就没有了。
6、构造函数与一般函数的不同:
构造函数和一般函数在写法上有不同;
1.在运行上也不不同;
2.构造函数是在对象一建立就运行,给对象初始化;
3.而一般方法是对象调用才执行,是给对象添加具备的功能。
4.一个对象建立,构造函数只运行一次。
5.而一般方法可以被该对象调用多次。
例:
class person
{
person() //构造函数
{System.out.println("*");}
}
class persondemo
{
public static void main(String[] args)
{
person p=new person();
}
}
构造代码块写法:
{
构造代码块执行语句;
}
构造代码块作用:给对象进行初始化。
对象一建立就运行,而且优先于构造函数执行。
构造代码块和构造函数的区别:
构造代码块是给所有对象进行统一初始化;
而构造函数是给对应的对象初始化。
构造代码块中定义的是不同对象共性的内容。
this:看上去是用于区分局部变量和成员变量同名情况
this代表它所在函数所属对象的引用。
简单说:哪个对象在调用this所在函数,this就代表哪个对象
this的应用:当定义类中功能时,该函数内部要用到调用该函数的对象时,这时用this表示这个对象。
但凡本类功能(函数)内部使用了本类对象,都用this表示。
this 用于区分成员变量。
用于构造函数之间进行互相调用
this 语名只能定义在构造函数的第一行,因为初始化要行执行。
当成员被静态修饰后,就多了一个调用方式,除了可以被对象调用外(p.age),还可以直接被类名调用(person.age),类名.静态成员。
被静态修饰后,就不在堆中,在一个单独的空间(方法区或共享区或数据区)
static特点:
1.随着类的加载而加载。
也就是说静态会随着类的消失而消失,说明它的生命周期最长。
2.优先于对象的存在
明确一点:静态是先存在,对象是后存在的。
3.被所有对象所共享
4.可以直接被类名所调用。
实例变量和类变量的区别:
1.存放位置。
类变量随着类的加载而存在于方法区中。
实例变量随着对象的建立而存在于堆内存中。
2.生命周期:
类变量生命周期最长,随着类的消失而消失。
实例变量生命周期随着对象的消失而消失。
静态使用注意事项:
1.静态方法只能访问静态成员(变量和方法)
非静态方法既可以访问静态也可以访问非静态。
2.静态方法中不可以定义this,super关键字
因为静态优先于对象存在,所在静态方法中不可以出现this。
3.主函数是静态的。
静态有利有弊:
利:对对象的共享数据进行单独空间的存储,节省空间。没有必要每一个对象中都存储一份。
可以直接被类名调用。(没对象只能用类名调用)
弊端:生命周期过长。
访问出现局限性。(静态虽好,只能访问静态)
class Person
{
String name;//成员变量,实例变量。
static String country = "CN";//静态的成员变量,类变量。
public static void show()
{
System.out.println("::::");
}
}
public static void main(String[] args)
主函数:是一个特殊的函数。作为程序的入口,可以被jvm调用。
------0605说明文档的建立/** 内容 */
类必须是public的 (用javadoc 编译)
一个类中默认会有一个空参数的构造函数,这个默认的构造函数的所属类一致。
如果类被public修饰,那么默认的构造函数也带public修饰符。
如果类没有被public修饰,那么默认的构造函数也没有public修饰符。
即默认构造函数的权限是随着类的变化而变化的。
------0606静态代码块
静态代码块格式:
static
{
静态代码块中的执行语句
}
特点:随着类的加载而执行,只执行一次。用于给类进行初始化。
静态代码块的执行顺序
*静态里面不能用this
*构造代码块能用this
------0607对象初始化过程
Person p=new Person("zhangsan",20);
该句话都做了什么事情?
1.因为new用到了Person.class.所以会先找到Person.class文件并加载到内存中。
2.执行该类中的static代码块,如果有的话,给Person.class类进行初始化。
3.在堆内存中开辟空间,分配内存地址。
4.在堆内存中建立对象的特有属性。并进行默认初始化。
5.对属性进行显示初始化。
6.对对象进行构造代码块初始化。
7.对对象进行对应的构造函数初始化。
8.将内存地址会给栈内存中的p变量。
------0608
非静态省略this.
静态省略类名.
静态方法被调用只有两种方式:1对象访问,2类名访问(必须是静态的)
------0609单例设计模式
23种设计模式
对象一定在堆里
想要保证对象唯一:(想法)
1.为了避免其他程序过多建立该类对象,先禁止其他程序建立该类对象。
2.还为了让其他程序可以访问到该类对象,只好在本类中,自定义一个对象。
3.为了方便其他程序对自定义对象的访问,可以对外提供一些访问方式。
保证对象唯一:(用代码实现)
1.将构造函数私有化。
2.在类中创建一个本类对象
3.提供一个方法可以获取到该对象。
当需要将事物的对象保证在内存中唯一时,就将以上的三步加上即可。
称为饿汉式:(不管怎样,先拿了空间再说)
class single
{
private static Single s=new Single();
private Single(){}
public static Single getInstance() //getInstance只是一个名字,起别的也行
{
return s;
}
}
方法被调用只有两种方式:1对象访问,2类名访问(必须是静态的)
------0610
对象是方法被调用时,才初始化,也叫做对象的延时加载。称为:懒汉式(因为懒,所以到非要用的时候才拿空间)
class single
{
private static Single s=null;
private Single(){}
public static synchronized Single getInstance()
{
if(s=null)
s=new Single();
return s;
}
}
为提高效率可以用双重判断来做,以减少对锁的判断
class Single
{
private static Single=null;
private Single(){};
public static Single getInstance(()
{
if(s=null);
{
synchronized (Single.class);
{
if(s=null);
s=new single();
}
}
return s;
}
}
------0701
extends
继承:
1.提高了代码的复用性。
2.让类与类之间产生关系。有了这个关系,才有了多态的特性。
注意:千万不要为了获取其他类的功能,简化代码而继承。必须是类与类之间有所属关系才可以继承。所属关系is a。
------0702
java语言中:java只支持单继承,不支持多继承(C++支持多继承).
多继承容易带来安全隐患:当多个父类中定义了相同功能,当功能内容不同时,子类对象不确定要运行哪个。
class a
{void show(a)}
class b
{void show(b)}
class c extends a,b
c.show() //??这里就出现问题了。show方法结果不确定
在具体调用时,要创建最子类的对象,因为:1有可能父类不能创建对象,2创建子类对象可以使用更多的功能,包括基本的也包括特有的。
一句话:查阅父类功能,创建子类对象使用功能。
------0703
子父类出现后,类成员的特点:
类中成员:1、变量。2、函数。3、构造函数。
super.变量和this.变量
父类引用 子类引用
------0704
新的关键词super
1.变量
如果子类中出现非私有的同名成员变量时,子类要访问本类中的变量,用this;子类要访问父类中的同名变量,用super。
super的使用和this的使用几乎一致。
this代表的是本类对象的引用。
super代表的是父类对象的引用。
super.父类
this.子类
------0705
子父类中的函数。
覆盖:当子类出现和父类一模一样的函数时,当子类对象调用该函数,会运行子类函数的内容。如同父类的函数被覆盖一样。
这种情况是函数的另一个特性:重写(覆盖)
当子类继承父类,沿袭了父类的功能,到子类中,但是子类虽具备该功能,但是功能的内容却和父类不一致,这时没有必要定义新功能,而是使用覆盖特殊,保留父类的功能定义,并重写功能内容。
覆盖注意事项:
1.子类覆盖父类,必须保证子类权限大于等于父类权限,才可以覆盖,否则编译失败。
2.静态只能覆盖静态。
子类覆盖父类是功能的扩展,父类中已经有的,子类中没有必要再覆盖,直接用super.方法名调用父类就可以。
例:
class Tel
{
void show()
{
System.out.println("number");
}
}
class NewTel extends Tel
{
void show()
{
super.show();//用super.方法名调用父类方法
System.out.println("name");
System.out.println("pic");
}
}
已经学的权限public private 还有一种什么都不写如上面的例子。
记住:
重载:只看同名函数的参数列表。
重写:子父类方法要一模一样。(包括返回值)
------0706
子父类构造函数this() super()
(构造函数不存在覆盖) 课0508构造函数特点函数名与类名相同
子类中至少有一个构造函数访问父类
注意:super()函数写在子类构造函数的第一行
this()函数写在构造函数的第一行
因此,一个函数内不可能同时出现this和super
在对子类对象进行初始化时父类的构造函数也会运行,那是因为子类的构造函数默认第一行有一条隐式的语名super();
super():会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super();
为什么子类一定要访问父类的构造函数。
因为父类中的数据,子类可以直接获取。所以子类对象在建立时,需要先查看父类是如何对这些数据进行初始化的。
所以子类在对象初始化时,要先访问一下父类中的构造函数。
如果要访问父类中指定的构造函数,可以通过手动定义super语名的方式来指定。
子类 实例化过程
结论:
子类的所有的构造函数,默认都会访问父类中空参数的构造函数。因为子类每一个构造函数内的第一行都才一句隐式super()
当父类中没有空参数的构造函数时,子类必须手动通过super语句形式来指定要访问父类中的构造函数。
当然:子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。
子类中至少有一个构造函数会访问父类中的构造函数。
注意:super语句一定定义在子类构造函数的第一行。
------0707
final:最终。作为一个修饰符。
1.可以修饰类,函数,变量。
2.被final修饰的类不可以被继承。为了避免被继承,被子类复写功能
3.被final修饰的方法不可以被复写。
4.被final修饰的变量是一个常量,只能赋值一次,既可以修饰成员变量,又可以修饰局部变量。当在描述事物时,一些数据的出现值是固定的,那么这时为了增强阅读性,都给这些值起了名字,方便于阅读。而这个值不需要改变,所以加上final修饰。作为常量:常量的书写规范所有字母都大写,如果由多外单词组成。单词间通过下划线(_)连接。
5.内部类定义在类中的局部位置上时,只能访问该局部被final修饰的局部变量。
已学class修饰符(public final)
-0712类是继承关系
接口是实现关系
implements实现
------0708
abstract抽象
抽象类的特点:
1抽象方法一定在抽象类中
2抽象方法和抽象类都必须被abstract关键字修饰
3抽象类不可以用new创建对象,因为调用抽象方法没意义
4抽象类中的抽象方法要被使用,必须由子类复写其所有的抽象方法后,建立子类对象调用。
如果子类只覆盖了部分抽象方法,那么该子类还是一个抽象类
以下论坛笔记摘抄:
下面比较一下两者的区别:
1.抽象类可以有构造方法,接口中不能有构造方法。
2.抽象类中可以有普通成员变量,接口中没有普通成员变量
3.抽象类中可以包含非抽象的普通方法,接口中的所有方法必须都是抽象的,不能有非抽象的普通方法。
4. 抽象类中的抽象方法的访问类型可以是public,protected和默认类型,但接口中的抽象方法只能是public类型的,并且默认即为public abstract类型。
5. 抽象类中可以包含静态方法,接口中不能包含静态方法
6. 抽象类和接口中都可以包含静态成员变量,抽象类中的静态成员变量的访问类型可以任意,但接口中定义的变量只能是public static final类型,并且默认即为public static final类型。
7. 一个类可以实现多个接口,但只能继承一个抽象类。
------0710
员工抽象类
------0711
模板方法
gettime程序运行时间
用到了abstract与final
------0712
接口:初期理解,可以认为是一个特殊的抽象类
当抽象类中的方法都是抽象的,那么该类可以通过接口的形式来表示。
class用于定义类
interface用于定义接口
接口定义时格式特点:
1.接口常见定义:常量,抽象方法。
2.接口中的成员都有固定修饰符。
常量:public static final
方法:public abstract
记住:接口中的成员都是public的
例:
interface Inter
{
public static final NUM=3;
public abstract void show();
}
class Test implements Inter//新的关键字implements
{
public void show(){}
}
接口:是不可以创建对象的,因为有抽象方法。
需要被子类实现,子类对接口中的抽象方法全都覆盖后,子类才可以实例化,否则子类是一个抽象类。
------0713
接口可以被多实现。
一个类在继承的同时还可以实现多个接口。
例:
class Test extends Demo implements Inter,InterA//Test类继承Demo又实现了Inter和InterA
接口可以实现多继承
------0714
接口的特点:
接口是对外暴露的规则
接口是程序的功能扩展
接口可以用来多实现
类与接口之间是实现关系,而且类可以继承一个类的同时实现多个接口。
接口与接口之间可以有继承关系。
------0715
基本功能用类,扩展功能用接口
------0801
多态:可以理解为事物存在的多种体现形态。
例:
猫 x=new 猫
动物 x=new 猫
------0802
1,多态的体现
父类的引用指向了自己的子类对象。
父类的引用也可以接收自己的子类对象。
2.多态的好处
必须是类与类之间有关系。要么继承,要么实现。
通常还有一个前提:存在覆盖。
3.多态的弊端
多态的出现大大的提高程序的扩展性。
4.多态的应用
以下是论坛的内容:
http://bbs.itheima.com/thread-18693-1-1.html
楼主可以记住多态的一些特点:
1:成员函数在多态调用时,编译看左边,运行看右边。
2:成员变量在多态中无论编译和运行,都参考左边。(引用型变量所属的类)
3:静态成员函数在对多态中,无论编译和运行,都参考左边。
你的属于第一种,实在不懂就硬背。
------0803
多态自始至终都是子类对象在做着变化。
instanceof关键字
a instanceof Cat//a是不是Cat这个类的类型
ClassCastException类型转换异常
------0808
object类:是所有对象的直接或者间接父类,传说中的上帝。
.equals方法
instanceof方法
------0901
内部类的访问规则:
1.内部类可以直接访问外部类中的成员,包括私有。
之所以可以直接访问外部类中的成员,是因为内部类中持有一个外部类和引用,格式 外部类名.this。
2.外部类要访问内部类,必须建立内部类对象。
直接访问内部类中的成员:
Outer.Inner in=new Outer().new Inner();
类可以被私有吗?
内部类可以,当内部类在外部类的成员位置时,是可以被private修饰。
------0902
访问格式:
当内部类定义在外部类的成员位置上,而且非私有,可以在外部其他类中,可以直接建立内部类对象。
格式:
外部类名.内部类名 变量名=外部类对象.内部类对象
Outer.Inner in = new Outer().new Inner();
2.
当内部类在成员位置上,就可以被成员修饰符所修饰。
比如:private:将内部类在外部类中进行封装。
static:内部类就具备static的特性。
当内部类被static修饰后,只能直接访问外部类中的static成员,出现了访问局限。
在外部其他类中,如何直接访问static内部类的非静态成员呢?
new Outer.Inner().function();
在外部其他类中,如何直接访问static内部类的静态成员呢?
Outer.Inner.function();
注意:当内部类中定义了静态成员,该内部类必须是static的。
当外部类中的静态方法访问内部类时,内部类也必须是static的。
------0904
匿名内部类:
1,匿名内部类其实就是内部类的简写格式。
2,定义匿名内部类的前提:内部类必须是继承一个类或者实现接口。
3,匿名内部类的格式:new 父类或者接口(){定义子类的内容}
4,其实匿名内部类就是一个匿名子类对象,而且这个对象有点胖。可以理解为带内容的对象。
5,匿名内部类中定义的方法最好不要超过3个。
------0905
异常:是问题的描述,将问题进行对象的封装。
异常分为两种:一种是严重的问题Error,一种是非严重的问题Exception。
throwable
|___Error
|___Exception
|___RuntimeException
------0906
异常体系的特点:异常体系中的所有类以及建立的对象者具备可抛性,也就是说可以被throw和throws关键字操作。只有异常体系具备这个特点。
异常处理格式:
try
{
需要被检测的代码;
}
catch(异常类 变量)
{
处理异常的代码:(处理方式)
}
finally
{
一定会执行的语句;
}
Throwable 类是 Java 语言中所有错误或异常的超类
例:
catch(Exception e)
{
System.out.println(e.getMessage());//getMessage()是Throwable的一个方法。
}
------0907
异常可以抛出或捕捉
抛出:throws Exception
捕捉:try{} catch(Exception e){}
------0908
在声明异常时,有几个异常,就对应几个catch块。
多异常中,声名的异常越具体,处理越具体,但记得具体的异常要放在上面,父类异常要放在最下面。
------0909
自定义异常:
例:
class FuShuException extends Exception
{
FuShuException(String msg)//父类中已经把异常信息的操作都作完了,所以子类只要在构造时,将异常信息传给父类就可以了。
{
super(msg);//通过父类的getMessage方法获取自定义的异常信息
}
}
class Demo
{
int div(int a,int b) throws FuShuException
{
if(b<0)
throw new FuShuException();//手动通过throw关键字抛出一个自定义异常对象。
return a/b;
}
}
当在函数内部出现了throw抛出异常对象,那么就必须要给对应在的处理动作。
要么在内部try catch处理,要么在函数上声明调用者处理。
------0910
throws和throw的区别
throws使用在函数上,后面跟的是异常类,可以跟多个,用逗号隔开。
throw使用在函数内,后跟的是异常对象。
------0911
Exception中有一个特殊的子类异常RuntimeException 运行时异常。
如果在函数内容抛出该异常,函数上可以不用声明,编译一样通过。
如果在函数上声明了该异常,调用者可以不用进行处理,编译一样通过。
对于异常分两种:
1.编译时被检测的异常
2.编译时不被检测的异常(运行时异常,RuntimeException以及其子类)
------1001
finally异常一定执行的代码
注意:
1,finally中定义的通常是关闭资源代码,因为资源必须释放。
2,finally只有一种情况不会执行,当执行到System.out(0);fianlly不会执行。 (jvm虚拟机退出)
------1002 异常的三种格式:
格式1
try
{}
catch
{}
格式2
try
{}
catch
{}
finally
{}
格式3
try
{}
finally
{}
记住:catch是用于处理异常,如果没有catch就人表有被处理过;如果该异常是检测时异常,那么必须声明。
------1003
异常在子父类覆盖中的体现:
1,子类在覆盖父类时,如果父类的方法抛出异常,那么子类的覆盖方法,只能抛出父类的异常或者该异常的子类。
2,如果父类方法抛出多个异常,那么子类在覆盖该方法时,只能抛出父类的子集。
3,如果父类或者接口的方法中没有异常抛出,那么子类在覆盖方法时,也不可以抛出异常。
如果子类方法发生了异常,就必须要进行try处理。绝对不能抛出。
------1004
求正方形和圆形的面积
------1005
总结:当函数内容有throw抛出异常对象,并未进行try处理,必须要在函数上声明,否则编译失败。
注意:RuntimeException除外,也就是说,函数内如果抛出是RuntimeException异常,函数上可以不用声明。
如果函数声明了异常,调用者需要进行处理。处理方法可以throws或try。
异常的好处:1,将问题进行封装。2,将正常流程代码和问题处理代码相分享,方便于阅读。
异常的处理原则:
1,处理方式有两种:try或者throws
2,调用到抛出异常的功能时,抛出几个,就处理几个。
3,多个catch,父类的catch放到最下面。
4,catch内,需要定义针对性和处理方式,不要简单的定义printstrackTrace,输出语句。也不要什么都不写。
当捕获到的异常,本功能处理不了时,可以继续catch中抛出。
try
{
throw new AException();
}
catch(AException e)
{
throw e;
}
如果该异常处理不了,但并不异于该功能出现的异常。可以将异常转换后,再抛出和该功能相关的异常。
try
{
throw new AException();
}
catch(AException e)
{
throw new BException();
}
或者异常可以处理,当需要将异常产生的和本功能相关的问题提供出去
------1006
练习,要看一看
第十一题:
class Fu
{
int num=4;
void show()
{
System.out.println("showFu");
}
}
class Zi extends Fu
{
int num=5;
void show()
{
System.out.println("showZi");
}
}
calss T
{
public static void main(String[] args)
{
Fu f=new Zi();
Zi z=new zi();
System.out.println(f.num);
System.out.println(z.num);
f.show();
z.show();
}
}
程序输出结果4,5,showzi,showzi
查看0802论坛笔记
---------------------- android培训、java培训、期待与您交流! ----------------------