面向对象
面向过程：过程就是功能、动作，就是说面对的主要是大量无序排列的功能（basic和C语言，VB是一个工具）
面向对象：其实就是对各种功能进行了打包分类，我们会先面对的是对象，再对其内的功能、动作进行调用
作用意义：面向对象是一种思想，能让复杂的事情简单化，能让我们从执行者转变为指挥者
匿名对象：当对对象的方法只调用一次时，使用匿名对象较方便；匿名对象作为实际参数进行传递时较为方便
1.封装（Encapsulation）
1.1 封装要点
（1）封装的意义：隐藏对象的属性和实现细节，对外提供公共访问方式，封装的出现才让的权限可以定义
（2）优点：<1>.隔离变化 <2>.便于使用 <3>.提高安全性
（3）Java从小到大的封装体：函数-->类-->包-->框架
1.2 构造函数
（1）规定： <1>.函数名与类名相同 <2>.不用定义返回值类型 <3>.不可以写return语句
（2）作用：给对象进行初始化，没有构造函数对象无法建立
（3）特点：<1>.对象一建立就执行 <2>.只执行一次
（4）注意：自定义构造函数后，系统不会默认添加空参数的构造函数
（5）构造代码块：对所有对象进行统一初始化，构造函数中共性内容定义在这里面
class Person
{
{
//构造代码块
}
Person(){
//空参构造函数，当没有添加构造函数时系统会默认添加这个
}
Person(String name){
//有参数的构造函数，定以后系统不会默认添加空参的构造函数
}
}1.3 this关键字
（1）this表示本类对象，是所在函数所属对象的引用
（2）this语句：this(参数)，构造函数间相互调用只能通过this语句，并且该语句只能定义在构造函数第一行
class Person
{
private String name;
Person(){
this("java");//this语句
}
Person(String name){
this.name = name;//this的用法1
}
}1.4 static(静态)关键字
（1）只能修饰成员，修饰内容被对象所共享，并且可直接被类名调用，写法为类名.静态成员
（2）静态变量(类变量)：随着类的加载而存放在方法区中，生命周期最长，被每个对象所共享，共性内容定义为静态变量较好
（3）静态函数：方法只要没用到非静态成员即可定义为静态
（4）特殊：当一个类中全部方法都是静态的时，应该私有化构造函数，禁止该类创建对象，这就是一个工具类
（5）方法区：存放共性内容，因为每个函数只是调用的数据不同，方法体是共性的，存在于这里
class Person
{
String name;
static String country = "CN";//静态变量（类变量）对象共享数据
public String getName(){
return "方法"+name+country; //普通方法可以引用静态成员
}
public static String getCountry(){//静态方法不能引用非静态成员
return "静态"+country;
}
}
class java
{
public static void main(String[] args){
Person p = new Person();
System.out.println("成员变量："+p.name);
System.out.println("静态成员变量："+Person.country);//可用直接用类名调用
System.out.println("========================================");
System.out.println("普通函数："+p.getName());
System.out.println("静态函数："+Person.getCountry());//可用直接用类名调用
}
}
（7）静态代码块：随着类的加载而执行，给类进行初始化，并且只执行一次
（8）对象的创建到消亡的全部过程（Person p = new Person();）
| <1>.编译java文档，把class文件加载进内存 |
| <2>.方法和静态成员存放在方法区中 |
| <3>.静态代码块初始化（如果有的话） |
|
<4>.在堆内存开辟空间，分配地址值
|
|
<5>.在堆内存中建立对象，并且对其属性进行默认初始化
|
|
<6>.对属性进行显示初始化
|
|
<7>.构造代码块初始化
|
|
<8>.特定构造函数初始化
|
|
<9>.内存地址值分配给类类型变量
|
|
<10>.对象被垃圾回收掉
|
| <11>.方法和静态成员从方法区中随着类的消亡而消亡 |
2.继承（Extend）
2.1 继承的要点
（1）优点：<1>.提高了代码的复用性 <2>.使类与类之间产生了关系，才有了多态的特性
（2）弊端：打破了类的封装性
（3）内存：创立的子类对象在堆内存中会有两块区域，一块为子类属性，一块为父类属性
（4）复写(重写、覆盖)注意：<1>.复写方法时，适当的使用【super.父类函数名(参数)】的方式简化代码 <2>.静态方法只能被静态方法所覆盖
（5）每一个子类的构造函数中第一行都有一行隐式的super();语句，调用父类空参构造函数。
<1>.父类必须有空参数的构造函数
<2>.如果真没有，子类构造函数第一行需手动指定要访问父类哪一个构造函数,如super(3);
class father
{
father(){}//父类必须要有空参构造函数
father(int x){
System.out.println("father......."+x);
}
public static void study(){}
}
class son extends father
{
son(){
super();//系统默认会添加这一句代码
System.out.println("son");
}
son(int x){
super(x);//手动指定要访问的构造函数
System.out.println("son........"+x);
}
public static void study(){}//只有静态方法能够覆盖静态方法
}
2.2 final关键字
（1）final修饰的变量是常量，只能赋值一次（可以修饰局部变量）
（2）final修饰的方法不能被覆盖
（3）final修饰的类不能被继承
（4）局部内部类只能访问该局部被final修饰的局部变量
final class java //final修饰的类是终类，不能被继承
{
final double PI=3.14;//PI是一个常数
final void test(){//方法不能被复写
System.out.println("final方法");
}
}2.3 抽象类（abstract）
（1）抽象类无法创建对象，因为调用抽象方法没意义
（2）继承抽象类，子类必须复写父类所有抽象方法，不然子类也是抽象类
2.4 接口（interface、implements）
（1）成员固定修饰符（默认系统添加，建议自己书写，方便阅读）
变量：public static final（全局常量）
方法：public abstract
（2）注意：<1>.一个类继承一个类的同时能实现多个接口 <2>.接口与接口之间支持多继承
（3）特点：<1>.对外暴露的规则 <2>.提高了功能的扩展性 <3>.降低了耦合性 (依赖性，可以各做各的，不影响结果)
（4）如何定义接口：一般都应该具有的功能通过继承传递；可能具有的功能定义为接口，并且可定义多个接口，通过实现来传递
（5）Java中的接口其实和现实中物理接口含义差不多，可通过以下代码来说明
/**
*需求：定义一个主板、显卡、声卡、网卡仿真关系来说明接口的意义（现实与Java的关系）
*设计：1.定义主板类，并且具有run()、cardRun()方法
* 2.只要显卡，声卡，网卡都接上电运行后主板即可运行
*
*/
interface PCI//物理主板上的PCI接口的规格
{
void open();
void close();
}
class MainBoard
{
public void run(){
System.out.println("主板开始启动，启动正常");
}
public void cardRun(PCI p){//表示主板上有PCI接口的插槽
if(p!=null){
p.open();
p.close();
}
}
}
class VedioCard implements PCI //表示显卡按照PCI接口规格设计
{
public void open(){};
public void close(){};
}
class SoundCard implements PCI //表示声卡按照PCI接口规格设计
{
public void open(){};
public void close(){};
}
class NetCard implements PCI //表示网卡按照PCI接口规格设计
{
public void open(){};
public void close(){};
}
class java
{
public static void main(String[] args){
MainBoard mb = new MainBoard();
mb.cardRun(new VedioCard()); //把显卡插在主板上
mb.cardRun(new SoundCard()); //把声卡插在主板上
mb.cardRun(new NetCard()); //把网卡插在主板上
mb.run();//主板运行
}
}3.多态（Polymorphism）
3.1 多态要点
（1）意义：父类引用指向子类对象，主要是为了解决函数参数列表的单指向性
（2）前提：父类引用只能调用子类继承或实现的方法，不能调用子类独有方法
（3）特点：<1>.提高代码扩展性
（4）注意：<1>.不要把父类对象转成子类类型 <2>.调用子类对象特有方法时代码实现方式如下
/**
*需求：如何使用父类引用调用子类特有方法
*/
abstract class Animal
{
abstract void eat();
}
class Cat extends Animal
{
public void eat(){
System.out.println("吃鱼");
}
public void catchMouse(){
System.out.println("捉老鼠");
}
}
class java
{
public static void main(String[] args){
Animal a = new Cat(); //类型提升，向上转型
Cat c = (Cat)a; //向下转型，想使用子类独有方法需要这样转型后使用
get(a);
}
public static void get(Animal a){
a.eat();
if(a instanceof Cat){
Cat c = (Cat)a;//强制转换
c.catchMouse();
}
}
}<3>.定义重载函数，如果函数之间有多态的关系，那么超类类型的参数必须定义在最下边，不然编译失败
（5）面试：多态使用时调用父类引用调用成员变量或者静态方法，全部指向的是父类。因为方法或者变量都已经绑定，静态优先于对象存在
3.2 instanceof关键字
（1）公式：待判断变量 instanceof 目标类型
（2）返回值：true 或 false
3.3 Object类（上帝类、根类、超类）
boolean | equals(Object obj) 指示其他某个对象是否与此对象“相等”。 |
Class<?> | getClass() 返回此 Object 的运行时类。 |
int | hashCode() 返回该对象的哈希码值。 |
String | toString() 返回该对象的字符串表示。 |
3.4 内部类（内置类、嵌套类）
（1）成员位置
<1>.意义：内部类就是在外部类中的一个事物。例如人与心脏。
<2>.访问方式：外部类名.内部类名 引用名 = new 外部类名().new 内部类名()
<3>.特点：a.内部类能访问外部类成员，包括私有。因为引用前都有隐式的 外部类名.this
b.内部类能被成员修饰符所修饰public、private、static、final、abstract
c.静态内部类特点与静态方法类似
访问静态内部类的非静态方法 new 外部类名().内部类名().方法名()
访问静态内部类的静态方法 外部类名.内部类名.方法名()
d.内部类通常被private修饰，因为内部类一般不对外暴露
（2）局部位置
<1>.注意：a.不能被成员修饰符所修饰 b.访问局部变量时，此变量必须被final所修饰
（3）匿名内部类
<1>.意义：匿名内部类实质上是一个匿名的子类对象
<2>.规则：此内部类必须实现或继承一个接口或类
<3>.格式：new 父类名(参数){类中的内容}
<4>.特点：不定义父类，可以用Object代替
//匿名内部类的实现
interface Inter
{
void method();
}
class Test
{
//补足代码，通过匿名内部类
public static Inter function(){
return new Inter(){//返回的是一个静态内部类
public void method(){
System.out.println("匿名内部类");
}
};
}
}
class java
{
public static void main(String[] args){
Test.function().method();
}
}3.5 包（package）
（1）包就是对类文件进行分类管理的文件夹，给类提供了多层命名空间
（2）编译方式：javac -d . java文件名.java
运行方式：java 包名.class文件名
（3）当出现包后需要注意的事项
<1>.创建对象，用到类的地方都要用 包名.类名 命名
<2>.创建的对象类中方法与类都要用public修饰符修饰
（4）关键字protected：只能该类的子类能够访问被此关键字修饰的方法
（5）权限修饰符的访问局限表
| public | protected | default | private | |
|---|---|---|---|---|
| 同一个类中 | 能 | 能 | 能 | 能 |
| 同一个包中 | 能 | 能 | 能 | |
| 不同包子类 | 能 | 能 | ||
| 不同包 | 能 |
（6）关键字import：简化包名书写的关键字，一般采用url地址值为包名。注意导入的是类，不能导入包
（7）jar包
<1>.当有多个包（文件夹）存在，携带不方便，可以打成一个jar类型的压缩包
<2>.dos命令行格式：jar -cf jar文件名.jar 包名,包名.....
<3>.web编程中的导包就是在classpath里指向jar包
<4>.JDK本地目录\jre\lib\rt.jar包中存储的是java的类库，java常用的对象都在此文件里面
<5>.JDK本地目录\lib\tools.jar包内有javac.exe主程序Main.class类
4.知识点
（1）native关键字表示调用本地系统的方法，本此关键字修饰的方法看不见方法体，不允许用户查看
（2）JDK本地目录\src.zip中是Java全部的源文件
（3）Java5块内存空间——栈内寸、堆内存、方法区、寄存器、本地方法区(native关键字)
3999
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
