面向对象 阶段性总结
面向对象概括：
面向对象过程思想：强调的是功能和行为；
面向对象思想：将功能封装对象，强调具备功能的对象。
面向对象的三个基本特征：封装，继承，多态。
什么是类：
类是对现实生活中事物的描述。描述事物其实就是在描述事物的属性行为。
什么是对象：
对象就是这类事物，实实在在存在的个体；
为什么要定义类：
根据需求以后的开发其实就是在找对象，没对象就要创建一个对象。
对象必须具备属性和方法。
面向对象的特点：找对象，建立对象，使用对象，维护对象类的关系。
面向对象内存分析
Cat C=new Cat( );
面向对象的一些知识点
类中的属性被称为成员变量（每个对象的属性都不同）；
类中的方法被称为成员方法（每个对象共享类中方法）；
方法的种类
1.无参无返回值：public void get(){};
2.无参有返回值：pbulic int get(){};
3.有参无返回值：public void get(int a){};
4.有参有返回值：public String get(int a){};
关键字
return 返回语句被用于返回
this 用来指当前对象
private 隐藏类中方法或属性对外界的可见性常用于封装类
toString 每个类的一个默认方法，用于把类以字符串显示
约定俗称的命名规范
1.类名首字母必须大写
2.方法和属性必须大写
3.由多个单词组成的类名或方法必须采用驼峰标示。
例如：
1 类名 StudentAdmin 2 方法或属性 StudentName
构造代码块
特点：对象只要已建立就运行了，而且优先于构造函数执行。
语法：
{ System.out.println( " " ); }
作用是给对象进行初始化。
构造代码块和构造方法的区别：
1.构造方法是对应的对象进行初始化，构造代码块是给所有的对象进行统一初始化。
2.构造代码块中定义是不同对象共性的初始化内容。
构造函数之间的调用
this关键字！！！
this：
1.区分局部变量和成员变量同名的情况。
2.代表本类对象，代表它所在函数（方法）所属对象的引用。
3.构造函数之间的调用只能通过this语句完成。
4.构造函数之间进行调用时this语句只能在第一行。
5.构造方法要先执行，如果构造方法当中还有初始化，那就去执行更细节的初始化。
Static关键字
作用：是一个修饰符，用于修饰成员（成员变量，成员方法）。
1.被static修饰后的成员变量只有一份。
2.当成员被static修饰之后，多了一种访问方式，除了可以被对象调用外，还可以被各类名直接调用。
特点：
1.随着类的加载而被加载。
2.优先于对象的存在。
3.被所有的对象所共享。
4.可以直接被类名所调用。
存放位置：
1.类变量随着类的加载而存在于data内存在。
2.实例变量随着对象的建立而存在堆内存。
生命周期：
1.类变量的生命周期最长，随着类消失而消失。
2.实例变量生命变量比类变量短，它随着对象的消失而消失。
静态方法注意事项
1.静态的方法只能访问静态变量。
2.非静态的方法即能访问静态的成员（成员变量，成员方法）也能访问非静态的成员。
3.静态的方法中是不可以定义this super关键字；
因为静态优先于对象存在，所以静态方法不可以出现this。
什么时候使用静态
1.什么时候使用静态的成员变量：
当属于同一个类的所有对象出现共享数据时；
需要将储存这个共享数据的成员变量用static修饰。
2.什么时候使用静态方法：
当功能内部没有访问到非静态的成员时（对象特有的数据）；
该功能可以定义静态的。
主函数(主方法)
1.public: (访问修饰符，公共的)代表该类或者函数访问权限最大的;
2.static: 代表函数随着类的加载就已存在了;
3.void: 代表主函数没有具体的返回值类型;
4.main: main不是Java中的关键字，它是一个特殊的单词，它能被JVM(Java 虚拟机)所标识；
5.String[] args: 函数的参数，参数类型是一个字符串数组，该数组的元素是字符串；
静态代码块
语法：
static { 静态代码块中执行语句; }
特点：随着类的加载而被执行，并且只会执行一次，并且优先于主函数。
作用：用于给类初始化。
继承
子类 extends 父类(){
}
概述：
1.提高代码的复用性，简化代码。
2.让类与类之间产生了继承关系，才有了后面的多态特性的存在。
注意:
千万不要为了其他的功能简化代码，而建立继承关系，必须要类与类之间存在继承关系，继承关系：is a。
子类拥有父类的成员，子类不能拥有父类中被private修饰后的成员。
Java多层继承
在多层继承最下层的子类拥有整个继承体系的成员，最上层的父类里面定义所有子类的共性描述。
Java中不支持多继承,只支持单继承
因为多继承存在安全隐患，当多个父类定义了相同的成员，子类对象不确定运行哪一个。
Java保留机制，并用了另一种方式体现多实现。
子父类中的成员变量
this: 代表当前对象的引用 this.变量
首先在本类找所需要的这个变量，如果没找到再在父类中找。
super():用于访问当前对象的父类成员 super.变量 直接父类中找所需变量。
子父类中的函数
当子类出现和父类中一样的函数，当子类对象调用该函数，运行的是子类中的函数。
如同父类中的函数被覆盖一样，这种情况就是函数的另一种特性:重写(覆盖)。
注意:
1.子类覆盖父类时，必须要保证子类权限大于或等于父类才能覆盖，否则编译错误。
访问修饰符:public>default>private
成员前面没加任何修饰访问权限，修饰法默认权限就是:default。
2.静态的函数只能覆盖静态的。
重点：
重载:只看同名的方法的参数。
重写:子父类方法要一模一样。
子父类中的构造函数
有了子父类之后构造函数的特点;
在对子类对象进行初始化的时候；
父类的构造方法也会运行，那是因为子类的构造函数默认第一行。
有一条隐式的语句:super();
子类每个构造方法第一行都有一个隐式的super();
对象转型
1.对象的向上转型:子类转成父类 默认进行(父类引用指向子类对象)；
2.对象的向下转型:父类转成子类 强制进行；
关键字:
instanceof:测试左边的对象是否是右边类的实例;
如果是返回ture,否则返回false。
多态
多态的体现：父类引用指向子类对象。
多态的前提:
1.必须得与类之间存在关系，可以是继承关系，也可以是实现关系。
2.必须得有重写。
多态的好处:大大的提高提高了代码的可扩展性。
多态的弊端:提高的程序可扩展性，只能用父类引用，访问到父类中的成员。
多态父类中的成员变量的特点
1.编译期间：参阅的是引用型变量所属的类中是否有调用的方法。
2.运行期间：参阅对象所属的类中是否有调用的方法。
匿名对象
概述：没有名字的对象。
匿名对象的使用方式：
1.当对象的方法只调用一次时，我们的匿名对象来完成，比较简化。
2.匿名对象可以被当作实参传递。
A(new B()); //相当与 B a=new B(); a.A();
Obejct类toString
概述：一个特殊的类
Obejct它是Java所有对象的直接或者间接父类，根父类(基类)，它里面定义的功能是所有对象都应该具备的。
注意：
当定义一个新类时，没有指明要继承某类，它默认继承Obejct类。
Obejct类equals()
==和Obejct里面的equals其实比较的就两个对象的内存地址是否一致。
final关键字
概述：final(最终)是一个修饰符。
1.final可以修饰类，函数，变量(成员变量，局部变量)。
2.被final修饰后的类不可以被其他类继承。
3.被final修饰后的函数不可以被重写。
4.被final修饰后的变量不允许被再次赋值。
final在对变量进行修饰时一定赋值，被final修饰后的变量我们称为它变量。
注意：
常量的命名规范；
1.字母都要大写
2.如果这个名字是由多个单词组成，在单词之间用_隔开。
抽象类
关键字：abstract它是一个修饰符。
可以修饰方法和类。
当我们多个类存在相同的功能，但是功能的主体不同，这时我进行向上抽取，只抽取功能的定义不抽取功能的主体。
抽象类的特点：
1.抽象方法一定要在抽象类中。
2.抽象类和抽象方法必须要被abstract关键字修饰。
3.抽象类是不能被创建对象的，因为调用抽象的方法没意义。
4.抽象类中方法要被使用，必须由子类重写抽象类中的方法。
5.抽象类中可以定义非抽象的方法，有时我们需要此类不能被new关键字创建对象时，可以用abstract将此类变成抽象类。
6.子类如果只重写一部分抽象方法，那末该类还是一个抽象类，如果抽象类的方法要被使用，子类必须重写抽象类中的所有方法。
注意：（抽象类和普通类的区别）
1.抽象类无法通过new关键字创建对象。
2.抽象类里面可有抽象方法。
接口
概述：接口是一个特殊的抽象类，当抽象类中全部是抽象类时，可以通过接口的形式来体现。
Class //用于定义类
interfance //用于定义接口
implements // 用于实现接口
接口中成员的格式：
public static final String 变量名=" ";//全局变量 pbulic abstract void show();//抽象方法
注意 ：
1.接口中只能出现public修饰符 访问。
2.接口不可以创建对象，因为里面有抽象方法，需要被子类实现，
子类对接口中的所有抽象方法实现后，子类才能够实例化，否则子类就是一个抽象类。
多实现：
Java不支持多继承，因为存在安全隐患 ，当父类中定义了相同功能，功能内容不同时，子类不确定要运行哪一个。
但是Java保留这种机制，并用另一种体现形式来完成表示 这就是多实现。
关系：
类与类之间：继承关系
接口与类之间：实现关系
接口与接口之间：继承关系
未完待续！！！
一.java语法基础
六天
1.什么是java
安装java(JDK)
配置java环境变量
使用Eclipse(IDE工具)
2.变量
使用变量
变量命名
数据类型
byte short int long
float double
char boolean
类型转换
自动类型转换(隐式)
强制类型转换(显式)
3.运算符
算数 + - * / %
关系 > < >= <= == !=
逻辑 && || !
赋值 = += -= *= /= %=
自加 ++ --
字符串连接 +
三目 <条件>?<真>:<假>
分支结构(上)
if语句
if(条件){
//条件为真运行
}
if-else语句
if(条件){
//条件为真运行
}else{
//条件为假运行
}
4.分支结构(下)
多重if
switch
循环结构(上)
while
do-while
5.循环结构(下)
for(;;){
}
break关键字
continue关键字
数组(上)
声明数组
初始化数组
赋值和遍历
6.数组(下)
数组复制
System.arraycopy();
Arrays.copyOf()
数组排序
Arrays.sort();
逆序输出
方法
无参数无返回值
无参数有返回值
有参数无返回值
有参数有返回值
二.java面向对象
1.类和对象
定义类
属性\方法
创建对象
对象.属性
对象.方法()
方法重载
2.构造方法
public <类名>(){
}
引用数据类型和引用数据类型数组
Dog[] dogs=new Dog[4];
dogs[0]=new Dog(...);
null和null指针异常
3.继承
class A extends B{
}
继承下构造方法的运行
子类对象实例化前先运行父类构造方法
4.向上造型
子类对象赋给父类引用
Pet p=new Dog();
可以将子类对象放入父类数组中
父类引用只能调用父类中的成员
方法重写
在子类中编写一个和父类中的某个
方法一模一样的方法
在父类引用调用方法时
运行的是子类重写后的方法
package
import
访问修饰符
private
默认
protected
public
final
修饰类
修饰方法
修饰属性
修饰局部变量
5.static
修饰属性
只在方法区保存1份
使用类名调用
修饰方法
该方法使用类名调用,无需对象
静态方法中不能使用实例成员
修饰初始化块
在类被JVM加载时运行
程序运行过程中只会触发一次
常量
public static final
使用类名调用,不能修改
在编译时,将常量替换成值
抽象类
抽象类不能实例化
抽象类能编写抽象方法
抽象方法数量不限(0~很多)
抽象方法
抽象方法不能有方法体
抽象方法必须在子类中被重写
除非子类也是抽象类
抽象方法必须在抽象类中
abstract和final关键字不能同时修饰
6.内部类
成员内部类
能使用外部类的私有成员
能使用<Outer>.this.<成员>
一般在外部类中使用
但是也可以在其他类中实例化
匿名内部类
在方法中通过继承类或实现接口
就地定义一个类,并创造对象
匿名内部类对象只能
在定义它的方法中使用
如果匿名内部类要使用它所在方法
的局部变量,需要将这个局部变量
视为被final修饰的
所有内部类都有独立的class文件
7.接口
什么是接口
怎么样定义接口
将class替换为interface
属性都是常量
方法都是抽象
不能实例化,也没有构造
接口的实现
implements
接口的注意事项
接口能继承接口
使用extends关键字
8.多态
什么是多态
使用步骤
1创建父类
2创建子类继承父类
3子类重写父类方法
4向上造型
5父类引用调用子类重写后的方法
强制类型转换
Dog d=(Dog)p;
容易产生类型转换异常
instanceof
判断一个对象是否属于一个类型
并返回boolean
9.GC
