------- android培训、java培训、期待与您交流！ ----------
一 理解面向对象
1 概述：面向对象其实是一种思想，由面向过程演变而来，是基于面向过程。面向对象将功能进行封装，强调对象。面向过程强调过程。
2 特性：面向对象有三大特性：封装，继承和多态。
3 作用：将问题简单化。角色由执行者变成指挥者。提高功能复用性。
4 类与对象的关系。
（1）类是对某种事物的描述。如，人这类事物，是个抽象的具体变现，它只是对这类人的行为属性的抽象描述。类封装的是事物的行为属性。行为就是方法，属性就是变量。
（2）对象是生活中存在事物。如，张三这个人，是个具体的人，他描述了具体的行为属性。
（3）创建对象由类通过new 关键字产生。
如：Person p=new Person();解读，在p在栈内存中开辟空间，new Person()在堆内存中开辟空间分配地址值，并把地址值赋值给p，p的引用就指向new Person()对象。此时p想操作对象的行为属性只需要调用他就行了。比如p.属性名或者p.方法名()。
（4）匿名对象。创建对象而且没有起名字的对象就叫匿名对象。当对对象的方法或属性使用一次时，可以使用匿名对象。匿名对象还可以作为实际参数进行传递。
通过一个例子说明类与对象的关系
//描述人这个类
class Person
{ //类里面的属性，年龄
int age;
//类里面的行为属性，获取年龄
public void int getAge()
{
return age;
}
}
class PersonDemo
{
public static void main(String[] args)//主函数
{
Person p=new Peson();//创建人对象
p.getAge();//调用方法
new Person().getAge();//创建匿名对象调用方法，只能调用一次
}
}5 成员变量和局部变量。
（1）成员变量作用于类中，在堆内存中，随着对象的创建而产生，由垃圾回收机制处理掉。
（2）静态变量被对象所共享，在方法区中，随着类的加载而加载，优先于对象存在，随着类的消失而消失，可以直接被类名调用。静态只能访问静态成员，非静态能访问静态成员和非静态成员。
（3）局部变量作用于函数中，在栈内存中，函数结束就释放。
二 面向对象特性：封装。
1 概述： 封装就是将对象的属性和行为细节隐藏起来，对外提供访问方式。函数和类都是封装的一种体现。
例如：人开门，人调用门的开门方式，门怎么开的人不需要知道，门只提供方式给你调用。
2 作用：提供安全性，复用性，便于使用，将变化隔离。
3 private关键字：是一个权限修饰符，是最小权限，是封装的一种变现形式。如果类中成员想不被外部其他类直接访问，可用private修饰。
（1）private用于修饰成员变量和成员函数，还可以修饰类，注意只能是内部类。
（2）private只在本类有效，即使外部类中创建对象也不能直接访问，所以类中需要提供访问成员的方式。一般来说，属性都需要隐藏起来。
（3）一般成员变量被private修饰，通常都会对外提供两种访问方式。一个是set()设置，一个是get()获取。
比如：private name; 对应就有两个方法setName()和getName();
4 构造函数与构造代码块
（1）构造函数名字与类名一致，不需要返回值类型。
（2）一个类中可以有构造函数多个构造函数，是重载关系。每个类中一定会有构造函数，如果没定义系统会自动添加一个无参数的构造函数，如果自己定义了，系统就不会添加。
（3）用于给对应对象进行初始化，对象一建立就会调用与之对应的构造函数，并执行，只执行一次。
（4）构造函数与一般方法不一样，构造函数是对象一创建就执行，而一般方法是通过对象调用，可以调用多次，如果不调用就不执行。
（5）构造代码块，用于给对象进行统一初始化，对象一建立就运行，只运行一次。并且构造代码块优先于构造函数执行。格式如下：
(
执行语句;
)
5 static关键字
（1）static用于修饰成员变量和成员函数，为对象共享，在共享区中。
（2）静态成员除了可以被对象调用外，还可以直接被类名调用。如：类名.成员
（3）静态成语随着类的加载而加载，随着类的消失而消失，生命周期最长。
（4）静态成语优先于对象存在，所以静态成员函数只能访问静态成员变量。静态函数中不可以出现this关键字。
（5）当类中出现共享数据时，该变量就使用static修饰，当定义的功能内部不需要访问到非静态成员时，就使用static修饰。
（6）静态代码块，用于给类进行初始化。随着类的加载而执行，只运行一次，优先于构造代码块执行。
格式：
static
{
语句；
}
6 this关键字
（1）this代表本类对象的引用，哪个对象调用就代表哪个对象的引用
（2）this应用：当定义功能时，该功能内部用的调用该功能的对象时，就用this关键字表示。
（3）构造函数间this的用法。this(参数);并且this语句必须放在第一行，初始化要先执行。
7 单例设计模式(只能创建一个对象)
思想：将构造函数私有，内部创建对象，给外界提供方法进行访问获取对象
（1）饿汉式：加载类时就创建对象
代码如下：
class Single
{
private static Single s=new Single();//内部创建对象
private Single(){}//私有构造函数，不给外界创建
//给外界提供方法进行访问获取对象,并且方法是静态的，可以直接用类名.方法访问
public static Single getInstanca()
{
return s;
}
}（2）懒汉式：延迟加载，调用方法才创建对象。如果多个线程运行，容易带来安全隐患，需要同步，但是比较低效，可以用双重判断的方式。同步的方法，后面线程内容会讲到。
代码如下：
class Single
{
private Single();
private static Single s=null;
public static getIntance()
{ //先判断再创建对象
if(s==null)
s=new Single();
return s;
}
}三 面向对象特性：继承
1 继承认识
（1）多个类功能属性相同时，将其抽取出来定义在一个类中，多个类用extends关键字继承该类便可，注意:一个类只能继承一个类。
如：class A{ }
class B extends A{ }
（2）特别注意：java不支持多继承，但支持多层继承和多实现。因为当多个父类定义了相同功能，但内容不一样时，子类不知道运行哪个，容易带来安全隐患。
（3）在使用API体系时，可以使用查阅父类创建子类的原则。因为父类定义的是子类的共性方法，父类有可能不能创建对象，而子类继承了父类的功能。
2 作用：提高代码复用性，简化代码，是多态的前提。
3 子父类中成员的特点
（1）子父类中成员变量的特点：子父类如果同时出现相同的非静态成员变量，访问子类变量用this，可以省略，访问父类对象用super，不能省略。
（2）子父类中成员函数的特点：子父类如果同时出现相同的成员函数，子类对象调用该方法，运行子类方法。
这种情况相当于覆盖，注意子类覆盖父类时，权限必须大于或等于父类权限（private权限除外），静态方法不能覆盖非静态方法。
如果子类出现跟父类相同功能时，只需要覆盖父类方法，定义子类的功能内容即可。
（3）子父类中构造函数的特点：子类创建对象时，构造函数会访问父类的构造函数，因为子类所有的构造函数第一行有一条隐视的super()，必须放在第一行
当父类中没有空参数的构造函数，子类必须手动通过this或super语句来指定要访问的构造函数
4 final关键字
（1）final是一个修饰符，可以修饰变量，函数和类
（2）被final修饰的类不能被继承
（3）被final修饰的方法不能被复写
（4）被final修饰的变量(成员变量和局部变量)只能赋值一次
5 抽象类(abstract)：多个类出现相同的功能但功能主体不一样，只需要向上抽取功能定义，定义在一个类中。
（1）抽象方法必须定义在抽象类中。
（2）抽象类可以定义非抽象方法。
（2）抽象类不能被创建对象。
（3）抽象方法要被使用，必须由子类覆盖其抽象类的所有抽象方法，创建子类对象，才能调用使用。
（4）子类覆盖抽象类方法，必须覆写全部抽象类，否则该子类还是个抽象类。
例子：
//定义抽象类Abstract类
abstract class Abstract
{
abstract void show();//定义抽象方法
void show1(){}//定义非抽象方法
}
//定义Demo类继承抽象类Abstract
class Demo extends Abstract
{
//覆盖show()方法，并定义自己的方法内容
public void show(){}
}
class AbstractDemo
{
public static void main(String[] args)
{
Demo d=new Demo();//创建子类对象
d.show();//调用方法，执行子类方法
}
}6 接口(interface)
（1）初期理解：是一个特殊的抽象类，类中定义的全部是抽象方法。
（2）接口可以被一个类多实现。接口与接口间可以存在继承关系。
（3）接口是对外暴露的规则，是程序的功能扩展。（自我的理解就是利用多态的特性将父类的引用作为方法中的参数列表可以接受任意子类对象）
（3）抽象类中的成员都有固定的修饰符
常量：public static final
函数：public sbstract
如果没有加修饰符，系统会自动加。
（4）接口不可以被实例化，子类实现接口，必须复写接口全部抽象方法，否则子类也是一个抽象类，不能实例化。
例子：
//定义接口
interface JieKou
{
void show1();//定义方法，都是抽象方法
void show2(){}//定义非抽象方法
}
//定义Demo类实现接口
class Demo implements JieKou
{
//覆盖show1()、show1()方法，并定义自己的方法内容
public void show1(){}
public void show2(){}
}
class AbstractDemo
{
public static void main(String[] args)
{
Demo d=new Demo();//创建接口子类对象
d.show1();//调用方法，执行子类方法
d.show2();
}
}四 面向对象特性：多态。
1 多态的特点：
（1）多态体现形式:父类的引用指向子类对象。如Person p=new Student();
（2）多态提高了程序的扩展性，但是只能使用父类的引用访问父类的成员。想用子类的方法，必须向下转型。如Student s=(Student)p;
（3）多态的前提必须是继承或实现关系。通常还需要子父类方法存在复写。
例子：
//定义类A
class A
{
void show1(){};//定义方法show1()
}
//定义B类继承类A
class B extends A
{
void show1(){}; //覆盖父类show1()方法
void show2(){}//定义show2()方法
}
class AbstractDemo
{
public static void main(String[] args)
{
A a=new B();//多态，父类引用指向子类对象
a.show1();//调用方法show1()，执行子类方法
a.show2();//调用方法show2()，编译失败，因为父类没有定义
B b=(B)a;//向下转型
b.show2();//调用子类show2()方法
}
}2 多态中成员的特点
（1）多态成员函数的特点，规律：编译看左边，运行看右边
在编译时期，参阅引用型变量所属的类是否有该调用方法，如果没有，编译失败。
在运行时期，参阅子类对象所属的类是否有该调用方法，如果有，运行子类方法，没有就运行父类方法。
（2）多态成员变量的特点，规律：无论编译运行都看左边。
（3）多态静态成员函数的特点，规律：无论编译运行都看左边。
四 内部类，将一个类定义在另一个类内部，就是内部类(内部类可以被private修饰)
1 内部类成员访问规则
（1）内部类可以直接访问外部类成员,包括私有（因为内部类持有一个外部类的引用，Outer.this）
（2）外部类访问内部类必须创建内部类对象
（3）外部其他类访问内部其他类必须创建内部类对象。格式是：Outer.Inner in=new Outer().new Innner()
（4）如果外部成员变量和内部成员变量以及内部局部变量出现同名，那么想访问外部成员变量，前面要加Outer.this；想访问内部成员变量，前面要加this；想访问内部局部变量，前面不用加。
例子：
class Outer//外部类
{
private int outer_num=1;//外部类成员变量
//外部类成员函数访问内部类成员变量需要先创建对象
void print()
{
Inner in=new Inner();
System.out.println(in.inner_num);
}
class Inner//内部类
{
int inner_num=2;//内部类成员变量
//内部类成员函数直接访问外部类私有成员变量
void show()
{
System.out.println(outer_num);
}
}
}
class Demo
{
public static void main(String[] args)
{
//外部其他类访问内部类成员，需要创建对象，格式：
Outer.Inner in=new Outer().new Innner();
in.show();//调用内部类方法
}
}2 静态内部类访问规则
（1）静态内部类只能访问外部类的静态成员，不能访问外部类的非静态成员
（2）外部其他类访问静态内部类非静态成员，只需创建外部类对象。格式：new Outer().Inner.方法
（3）外部其他类访问静态内部类静态成员，不需要创建对象。格式：Outer.Inner.方法
（4）如果内部类定义静态成员，该内部类也必须是静态的，否则编译失败。
（5）当外部类静态方法访问内部类时，内部类也必须是静态的。
3 内部类定义在外部类局部位置（不能被static和private修饰）
（1）内部类还是可以访问外部类成员
（2）内部类访问自己所在的局部变量时，该变量必须被final修饰。
4 匿名内部类（就是没有名字的内部类，其实就是内部类的简写格式）
（1）匿名内部类的前提是必须继承或实现一个类
（2）格式: new 接口或父类(){子类方法}
（3）如果匿名类对象想调用多个方法，应该利用多态给对象起个名字，但是多态有局限性，不能使用子类的特有方法
（4）如果内部类继承或实现的父类中，抽象方法超过3个，不建议定义匿名内部类，因为子类要覆盖父类的全部抽象方法。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
