黑马程序员---java基础之面向对象(二)

------- 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继承personStudentsaa(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个。

------- android培训、java培训、期待与您交流！ ----------