---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ----------------------
一、面向对象
一、概述
Java是一种面向对象的编程语言，对象是Java语言的基础，没有对象，就没有Java。任何功能都是通过对象来实现的，就是将功能封装成对象，让对象去调用这些功能。
将面向对象思想提升到一种境界就是：万物皆对象。
1、对面向对象的理解：
1）面向对象是相对面向过程而言的，且基于面向过程的。
2）将复杂的事情简单化。
3）面向对象将以前的过程中的执行者，变成了指挥者。
4）面向对象这种思想是符合现在人们思考习惯的一种思想。
5）面向对象的三个特征：封装(encapsulation)、继承(inheritance)、多态(polymorphism)。
二、封装
1）定义：封装是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
2）好处：将变化隔离；便于使用；提高重用性；安全性。
3）封装原则：将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问。
三、匿名对象
1、简述：所谓匿名对象，就是创建的对象没有名字，直接使用。
2、匿名对象的使用场景：
1）当对方法只进行一次调用的时候，可以使用匿名对象。
2）当对象对成员进行多次调用时，不能使用匿名对象。必须给对象起名字。
四、private关键字
定义：private是一个权限修饰符，用于修饰成员（成员变量和成员函数），被私有化的成员只在本类中有效。
注意：私有仅仅是封装的一种体现形式而已。
私有的成员：其他类不能直接创建对象访问，所以只有通过本类对外提供具体的访问方式来完成对私 有的访问，可以通过对外提供函数的形式对其进行访问。
好处：可以在函数中加入逻辑判断等操作，对数据进行判断等操作。
五、成员变量和局部变量的区别
1）成员变量直接定义在类中。
局部变量定义在方法中，参数上，语句中。
2）成员变量在这个类中有效。
局部变量只在自己所属的大括号内有效，大括号结束，局部变量失去作用域。
3）成员变量存在于堆内存中，随着对象的产生而存在，消失而消失。
局部变量存在于栈内存中，随着所属区域的运行而存在，结束而释放。
六、成员访问权限比较
成员修饰符 public protected default(默认) private
同一个类中 OK OK OK OK
同一个包中 OK OK OK NO
子类访问 OK OK NO NO
不同包中 OK NO NO NO
七、构造函数
一、定义：用于给对象进行初始化，是给与之对应的对象进行初始化，它具有针对性，函数中的一种。
二、特点：
1）该函数的名称和所在类的名称相同。
2）不需要定义返回值类型。
3）该函数没有具体的返回值。
注意：
1）所有对象创建时，都需要初始化才可以使用。
2）一个类在定义时，如果没有定义过构造函数，那么该类中会自动生成一个空参数的构造函数，为了方便该类创建对象，完成初始化。如果在类中自定义了构造函数，那么默认的构造函数就没有了。
3）一个类中，可以有多个构造函数，因为它们的函数名称都相同，所以只能通过参数列表来区分。所以，一个类中如果出现多个构造函数。它们的存在是以重载体现的。
三、构造函数和一般函数区别
1）两个函数定义格式不同。
2）构造函数是在对象创建时，就被调用，用于初始化，而且初始化动作只执行一次。 一般函数，是对象创建后，需要调用才执行，可以被调用多次。
四、何时使用构造函数
分析事物时，发现具体事物一出现，就具备了一些特征，那就将这些特征定义到构造函数内。
五、构造代码块和构造函数区别
构造代码块是给所有对象进行统一初始化，是所有对象的共性初始化方式内容。如任何孩子出生都要哭几声。
构造函数是给对应的对象初始化，不同的对象有各自的特性，需要选择不同的构造函数初始化。
八、this关键字
一、定义：用于区分局部变量和成员变量同名的情况。即this代表着当前对象的引用。
二、特点：
1）this代表了本类的对象，即代表了它所在函数所属对象的引用，也就是说，哪个对象调用这个函数，this就代表哪个对象。
2）一般情况下，this都是被省略的，需要使用的时候才需加上。
三、this应用：
1)当定义类中的功能时，该函数内部要用到调用该函数的对象时，这时用this来表示调用这个函数的对象。
2)只要本类功能内部使用了本类对象，都用this表示。
九、static静态函数
一、定义：是一个修饰符，用于修饰成员(成员变量和成员函数)。
二、static特点：
1）随着类的加载而加载，在类中生命周期最长。
2）优先于对象而存在。
3）可以被所有对象共享。
4）可以直接被类名调用。
三、static的用法：修饰成员：包括成员变量和成员方法当成员被static修饰后，就多了一种调用方式，即可以被对象和类名调用。
四、弊端：
1）有些数据是对象特有的数据，是不可以被静态修饰的。因为那样的话，特有数据会变成对象的共享数据。这样对事物的描述就出了问题。所以，在定义静态时，必须要明确，这个数据是否是被对象所共享的。
2）静态方法只能访问静态成员，不可以访问非静态成员。
因为静态方法加载时，优先于对象存在，所以没有办法访问对象中的成员。
3）静态方法中不能使用this，super关键字。
因为this代表对象，而静态在时，有可能没有对象，所以this无法使用。
4）主函数是静态的。
五、两个小问题
1）静态代码块的特点和作用有哪些?
就是一个有静态关键字标示的一个代码块区域。定义在类中。
2）.静态代码块的特点和作用有哪些?
就是一个有静态关键字标示的一个代码块区域。定义在类中。
-------------------------------------------------------------------------------------------------------------------
十、继承
一、好处：
1）提高了代码的复用性。
2）让类与类之间产生了关系，提供了另一个特征多态的前提。
二、为什么不支持多继承呢?
因为当一个类同时继承两个父类时，两个父类中有相同的功能，那么子类对象调用该功能时，运行哪一个呢？因为父类中的方法中存在方法体。
但是java支持多重继承。A继承B B继承C C继承D。
多重继承的出现，就有了继承体系。体系中的顶层父类是通过不断向上抽取而来的。它里面定义的该体系最基本最共性内容的功能。
所以，一个体系要想被使用，直接查阅该系统中的父类的功能即可知道该体系的基本用法。那么想要使用一个体系时，需要建立对象。建议建立最子类对象，因为最子类不仅可以使用父类中的功能。还可以使用子类特有的一些功能。
三、子类实例化过程
1）子类所有的构造函数默认均访问父类中的空参数构造函数，因为子类每个构造函数内的第一行均有一句隐式的super();语句。
2）当父类中悟空参数构造函数时，子类必须手动通过super语句的形式指定要访问的父类中的构造函数。
3）子类构造函数也可手动指定this语句，来访问本类中的构造函数，但子类中至少要有一个构造函数访问父类的构造函数。
示例1:
abstract class Employee//建立员工抽象类
{
//将三个属性设为私有
private String name;
private String id;
private double pay;
//用构造函数给三个属性初始化
Employee(String name,String id,double pay)
{
this.name=name;
this.id=id;
this.pay=pay;
}
//因为经理和员工工作的不一样所以为抽象
public abstract void work();
}
//经理类继承了员工
class Manager extends Employee
{
private int bouns;
//继承了员工的属性并添加了bouns奖金
Manager(String name,String id,double pry,int bouns)
{
super(name,id,pry);//父类已经定义完了.直接使用就OK了
this.bouns=bouns;
}
public void work()//覆盖抽象方法.
{
System.out.println("manager work");
}
}
class Pro extends Employee//继承员工
{
Pro(String name,String id,double pry)
{
super(name,id,pry);
}
public void work()//覆盖员工的抽象方法
{
System.out.println("pro work");
}
}
class AbstractTest
{
public static void main(String[] args)
{
System.out.println("Hello World!");
}
} -------------------------------------------------------------------------------------------------------------------
十一、多态
一、定义：可理解为事物存在的多种体现形态。又称为动态绑定，是java的核心机制之一。
理解：多态是在运行期间，判断引用实际类型，根据实际类型调用相应的方法。
二、多态的体现形式：
1）父类的引用指向了自己子类的对象。
2）父类的引用可接收子类的对象。
三、多态的前提：
1）必须是类与类之间的关系，如继承和实现关系。
2）要存在覆盖的操作，父类中必须由方法被子类覆盖，即重写。
3）有父类引用指向子类对象。
四、好处：大大提高了程序的扩展性。
五、弊端：虽然提高扩展性，但是只能使用父类的引用访问父类中的成员，不可预先使用子类。这是由于，子类在父类之后加载，此时还没有子类被加载。
示例2:
class Mainboard//定义一个主板类
{
void run()//让主板运行
{
System.out.println("mainboard run");
}
public void usePCI(PCI p)//PCI p=new NetCard()//接口型引用指向自己的子类对象
{
if(p!=null)//如果p不等于空开始执行开启.关闭
{
p.open();
p.close();
}
}
}
interface PCI//PCI接口
{
public void open();
public void close();
}
class NetCard implements PCI//定义网卡.实现PCI接口
{
public void open()//覆盖其开启和关闭的方法
{
System.out.println("netcard open");
}
public void close()
{
System.out.println("netcard colse");
}
}
class DuoTaiDemo4
{
public static void main(String[] args)
{
Mainboard m=new Mainboard();//创建主板对象
m.run();
m.usePCI(new NetCard());//使用主板的PCI.往里面插入网卡.
}
8508
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
