------- android培训、java培训、期待与您交流! ----------
面向对象:
面向对象是相对面向过程而言,面向对象和面向过程都是一种思想;
面向过程:强调的是功能行为
面向对象:将功能封装进对象,强调具备了功能的对象.
面向对象是基于面向过程的;
对象的分析:
1.名词提炼法:将需求中的名词提取出来,然后进行对象定义,具体的功能看属于哪个对象,就定义在哪个对象里面.
2.谁拥有数据,谁就向外提供操作这些数据的方法.
面向对象的三个特征:封装,继承,多态.
开发其实就是找对象用,没有对象就创建一个对象.(找对象,建立对象,使用对象,维护对象的关系)
类和对象的关系:
1-类就是对现实生活中事物的描述.对象就是这类事物,实实在在存在的个体.
2-现实生活中的对象想要描述:提取对象中共性内容,对具体内容的抽象.
映射到java中,描述就是class定义的类.
具体对象就是对应java在堆内存中用new建立的实体.
3-描述事物其实就是在描述事物的属性和行为(功能).
属性对应的类中的变量,行为对应的类中的函数(方法).
其实定义类,就是在描述事物,就是在定义属性和行为,属性和行为共同成为类中的成员(成员变量和成员方法)
4-类类型的变量指向对象(实体).
指挥对象的方式是:对象.对象成员(或方法);
实例变量和类变量的区别:
1.存放位置:
类变量随着类的加载而存在于方法区中;
实例变量随着对象的建立而存在于堆内存的对象中.
2.生命周期:
类变量生命周期最长,随着类的消失而消失.
实例变量生命周期随着对象的消失而消失.
类的构成:
一个类中通常有:成员变量,成员方法,构造函数,构造代码块,静态代码块,其各自特点为:
成员变量和局部变量的区别:
1-作用范围:
成员变量作用于整个类中.
局部变量作用于函数中或者语句中.
2-在内存中的位置:
成员变量:在堆内存中,因为对象的存在,才在内存中存在.
局部变量:存在栈内存中
构造函数:
对象一建立就会调用与之对应的构造函数.
细节:当一个类中没有定义构造函数时,那么系统会默认给该类加入一个空参数的构造函数.当已经定义了构造函数后,则系统不会默认添加空构造函数.
在函数中调用本类的构造函数用this();调用父类(超类)的构造函数用super();
构造函数和一般函数的不同:
构造函数是在对象一建立就运行,给对象初始化;
一般函数是对象调用才执行,就是给对象添加对象具备的功能.
一个对象建立,构造函数只运行一次,而一般函数可以被该对象多次调用.
什么时候定义构造函数?
当分析事物时,该事物存在具备一些特性或者行为,那么将这些内容定义在构造函数中.
特点:1.函数名与类名相同.
2.不用定义返回值类型.
3.不可以写return语句.
>>作用:给对象进行初始化.
class Person{//定义一个person类,定义一些基本功能,
String name;
int age;
Person(String name,int age){//带参数的构造函数
this.name = name;
this.age = age;
}
Person(){//空参数的构造函数,构造函数可以重载
this.name = null;
this.age = 0;
}
}
注意:1.默认构造函数的特点.
2.多个构造函数时,是以重载的形式存在的.
构造函数的权限:
一个类默认会有一个空参数的构造函数,这个默认的构造函数的权限和所属类一致.
如果类被public修饰,那么默认的构造函数的权限也带public修饰符.
如果类没有被public修饰,那么默认的构造函数也没有public修饰.
默认构造函数的权限是随着类的变换而变换的.
构造代码块:
作用:给对象进行初始化.
>>对象一建立就运行,而且优先于构造函数执行,
和构造函数的区别.
>>构造代码块是给所有对象统一初始化,而构造函数是给对应的对象初始化.
使用:构造函数中定义的是不同对象共性的初始化内容.
class 对象
{
{
构造代码块//最先执行.
}
对象属性;
构造函数;
对象方法()
}
静态代码块:
格式:
static
{
静态代码块中的执行语句;
}
特点:随着类的加载而执行,只执行一次.并优先于主函数执行.
用于给类进行初始化的.
匿名对象:
匿名对象是对象的简化形式
匿名对象两种使用情况
1.当对对象方法仅进行一次调用的时候.(如果对一个对象进行多个成员调用;必须给这个对象起个名字)
2.匿名对象可以作为实际参数进行传递
关键字
this关键字:就是代表本类的对象.this代表它所在函数所属对象的引用.
简单说:哪个对象在调用this所在的函数,this就代表哪个对象.
this的应用:当定义类中功能(函数)时,该函数内部要用到调用函数的对象时,这时用this来表示这个对象.
但凡本类功能内部使用了本类对象,都用this表示.
this语句:
只能用于构造函数间进行调用.
this(参数)
注意:this语句只能定义在构造函数的第一行,因为初始化要先执行!!!
Super关键字
super代表的是父类对象的引用.
用法和this几乎一模一样;
public static void main(String[] args){
speak(new Person());
}
public static void speak(Person p){//定义一个说话方法,参数类型是person,只要是person的子类都可以,多态的体现
if(p instanceof Person)
p.show();
}
class Person{//定义一个person类,定义一些基本功能,
String name;
int age;
Person(String name,int age){
this.name = name;//给本类对象的属性赋值
this.age = age;
}
Person(){
this.name = null;
this.age = 0;
}
public void show(){
System.out.println("name = "+name+"::age ="+age);
}
}
class Studentsaa extends Person {//student继承person
Studentsaa(String name,int age){
super(name, age);//调用父类的有参数的构造函数
}
}
static(静态)关键字
用法:是一个修饰符,用于修饰成员(成员变量,成员函数),用于修饰可以共享数据的成员. 被static修饰后的成员存放在方法区(共享区).
当成员被静态修饰后,就多了一个调用方式,出了可以被对象调用外,还可以直接被类名调用. <类名.静态成员>
static特点:
1.随着类的加载而加载;也就是说静态会随着类的消失而消失,说明它的生命周期最长.
2.优先于对象存在
<明确一点:静态是先存在的,对象是后存在的>
3.被所有对象所共享
4,可以直接被类名字所调用.
class person{
String name;//成员变量,实例变量,只有在对象调用时才运行.
static String country = "CN";//静态的成员变量,类变量.随类的调用而产生.
}
静态的使用注意事项:
1,静态方法只能访问静态成员(方法和变量);
非静态方法即可以访问静态(方法,变量),也可以访问非静态(方法,变量).
2.静态方法中不可以定义this,super关键字
因为静态优先于对象存在,所有静态方法中不可以出现this.
3.主函数是静态的.
静态有利有弊:
>>利:对对象的共享数据进行单独空间的存储,节省空间,没有必要每个对象中都存一份
可以直接被类名调用.
>>弊:生命周期过长,访问出现局限性(静态虽好,只能访问静态.)
>>什么时候使用静态<<
要从两方面下手:因为静态修饰的内容有成员变量和函数.
<<什么时候定义静态变量(类变量)?>>当对象中出现共享数据时,该数据用静态修饰,对象用的特有数据要定义成非静态,存在于对象内部(堆内存).
<<什么时候定义静态函数?>>
当功能内部没有访问到非静态数据(对象的特有数据),那么该功能可以定义成静态.
>>>静态的应用<<<
每一个应用程序中都有共性的功能.
可以将这些功能进行抽取,独立封装,以便复用.
将方法都静态后,可以方便于是用,但是该类还是可以被其他程序建立对象.
为了更为严谨,强制让该类不能建立对象.
可以将该对象的构造函数私有化.
关键字final:
最终的意思,作为一个修饰符.
1.可以修饰类,函数,变量.
2.被final修饰的类不可以被继承.为了避免被继承,被子类重写功能.
3,被final修饰的方法不能被重写.
4,被final修饰的变量是一个常量,只能赋值一次,既可以修饰成员变量,也可以修饰局部变量;;当描述事物时,一些数据的出现,值是固定的,那么这时为了增强阅读性,都给这些值起个名字,方便于阅读.而这个值不需要改变,所以加上final修饰.
作为常量:常量的书写规范所有字母都大写,如果由多个单词组成,单词间通过_连接.
5,内部类定义在类中的局部位置上时,只能访问该局部被final修饰的局部变量.
内部类
将一个类定义在另一个类的里面,对里面那个类就称为内部类(内置类,嵌套类);
class Out{
public void show(){
System.out.println("outer");
}
class Inner{//内部类,定义在成员位置上
System.out.println("inner");
}
}
内部类的访问规则:
1.内部类可以直接访问外部类中的成员(变量和方法),包括私有.
之所以可以直接访问外部类中的成员,是因为内部类中持有了一个外部类的引用,格式: 外部类名.this
2.外部类要访问内部类必须建立内部类对象.
访问格式:
1.当内部类定义在外部类的成员位置上,而且非私有,可以在外部其他类中.
可以直接建立内部类对象.
格式
外部类名.内部类名 变量名 = 外部类对象.内部类对象;
2,当内部类在成员位置上,就可以被成员修饰符所修饰.
比如,private:将内部类在外部类中进行封装.
class Outer
{
int x = 3;
void method(final int a)
{
final int y = 4;
class Inner//内部类定义在局部位置,不能被成员修饰符修饰
{
void function()
{
System.out.println(y);//只能访问被final修饰的y
}
}
new Inner().function();//调用内部类的function方法
}
}
static:内部类就具备了静态的特性.
当内部类被static修饰后,只能直接访问外部类中的static成员,出现了访问局限.
在外部其他类中,如何直接访问static内部类的非静态成员呢?
new 外部类名.内部类名().成员();
在外部其他类中,如何直接访问static内部类的静态成员呢?
外部类名.内部类名.成员();
class person{
String name;//成员变量,实例变量,只有在对象调用时才运行.
static String country = "CN";//静态的成员变量,类变量.随类的调用而产生.
}
System.out.println(person.country);//可以直接类名.名称 调用
注意:当内部类中定义了静态成员,该内部类必须是static的.
当外部类中的静态方法访问内部类时,内部类也必须是static的.
当描述事物时,事物的内部还有事物,该事物用内部类来描述.
因为内部事物在使用外部事物的内容.
内部类定义在局部时:
class Outer
{
int x = 3;
void method(final int a)
{
final int y = 4;
class Inner
{
void function()
{
System.out.println(y);//只能访问final的y
}
}
new Inner().function();//调用内部类的function方法
}
}
1.不可以被成员修饰符修饰.
2.可以直接访问外部类中的成员,因为还持有外部类中的引用.
但是不可以访问它所在的局部中的变量,只能访问被final修饰的局部变量.
匿名内部类:
abstract class Smoke{
public abstract void smoke();
}
class Main{
public static void main(String[] args){
Smoke s = new Smoke(){//定义一个Smoke的匿名内部类(匿名子类对象),实现了smoke方法
public void smoke(){
System.out.println("抽烟");
}
};
s.smoke();//调用smoke方法
}
}
1,匿名内部类其实就是内部类的简写格式。
2,定义匿名内部类的前提:
内部类必须是继承一个类或者实现接口。
3,匿名内部类的格式: new 父类或者接口(){定义子类的内容}
4,其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。 可以理解为带内容的对象。
5,匿名内部类中定义的方法最好不要超过3个。