面向对象：类、对象、类和对象的关系！！！
1：类
类是具有相同的属性和方法的一组对象的集合。类定义了对象的特征（属性）和行为（方法）。
类的属性：对象所拥有的静态特征在类中表示时称为类的属性。
类的方法：对象执行的操作称为类的方法。
2：对象
现实世界中客观存在的事物，对象具有的特征：静态特征和动态特征。
静态特征：可以用某些数据描述的特征。
动态特征：是对象所表现的行为或具有的功能。
3：类和对象的关系
类是多个对象进行综合抽象的结果，是实体对象的概念模型，而对象是一个类的实例，类是对象的类型。
在面向对象的编程思想中，对象的静态特征称为对象的属性，动态特征称为对象的方法。
在实际编程中，对象的属性被存储在变量中，对象的方法则是通过定义方法来实现的。
下面我们展开来具体说说
成员变量和局部变量：
作用范围：成员变量作用于整个类中；局部变量变量作用于函数中，或者语句中。
在内存中的位置：成员变量，在堆内存中，因为对象的存在，才在内存中存在；局部变量，存在栈内存中。
匿名对象：
匿名对象使用方式一：当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化（凡是简化都有局限性）。如果对一个对象进行多个成员调用，必须给这个对象起个名字。
匿名对象使用方式二：可以将匿名对象作为实际参数进行传递。
例子：
Car c = new Car(); new Car().num = 5;
c.num = 5; new Car().color = "blue";
c.run(); new Car().run();
对上面的例子来个说明吧，以前我们都是写成左边那样的，先有一个car类，创建一个c对象，然后去对它的属性和方法进行操作，他们都通过点来调用，这边是可以重复调用的吧，可就是重复使用的吧。在看右边，这就是我们说的匿名对象，它没有名字，所以叫匿名对象，new Car()就是在堆内存中创建了一个对象，new Car().num = 5;这句话就是创建了一个对象，把num改为了5，其他的没人任何意义，new Car().color = "blue";这句话也是同理，也是new出来的一个新对象，它只是将颜色变成了blue，这两句话执行完之后就变成了垃圾，内存会在适当的时候进行回收。但是new Car.run()就不一样了，它不一定是调用一次但是左边的老方法没有这个缺陷，这就需要我们在适当的时候去使用这个匿名对象。
第一大特征：封装Encapsulation
是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
好处：将变化隔离、便于使用、提高复用性、提高安全性。机箱的例子：我们看不到里面的东西；我们不需要了解里面是怎么工作的的，我们直接使用它；机箱可以重复使用；它没有暴露在外面，它没有安全隐患。
封装的原则：将不需要对外提供的内容都隐藏起来；吧属性都隐藏，提供公共方法对其访问。
class Person {
int age;
private void speak() {
System.out.println("age="+age);
}
}
class PersonDemo {
public static void main(String[] args) {
Person p = new Person();
p.age = -20;
}
}
这个代码中年龄是没有修饰的，我们在外部可以设置年龄成-20，当然这就不符合现实了，所以这就有安全隐患了，我对Person类进行封装来看。
class Person {
private int age;
public void setAge(int a) {
if(a>0 && a<130) {
age = a; speak();
} else
System.out.println("feifa age");
}
public int getAge() {
return age;
}
private void speak() {
System.out.println("age="+age);
}
}
class PersonDemo {
public static void main(String[] args) {
Person p = new Person();
p.age = -20;
p.setAge(-40);//这里既是设置年龄是一个负数，但是它不能将年龄赋值为负数，这就提高了安全性
speak() ;
}
}
private :私有，权限修饰符：用于修饰类中的成员(成员变量，成员函数)。
私有只在本类中有效。
将age私有化以后，类以外即使建立了对象也不能直接访问。 但是人应该有年龄，就需要在Person类中提供对应访问age的方式。
注意：私有仅仅是封装的一种表现形式。之所以对外提供访问方式，就因为可以在访问方式中加入逻辑判断等语句。对访问的数据进行操作。提高代码健壮性。
构造函数：
特点：函数名于类名相同； 不用定义返回值类型； 不可以写return语句。
作用：给对象进行初始化。如果所有的构造函数都被私有化了，那么这个类就不能创建对象了。如果是其中一个函数被私有化，那就不能创建这个构造函数对应的对象。
注意：1、默认空参的构造函数的特点（自定义了构造函数后，默认构造函数就没了）。2、多个构造函数是以重载的形式出现的 3、构造函数不存在继承，也就没有
覆盖，但是可以通过this（），或super()相互调用。
对象一建立就会调用与之对应的构造函数。
构造函数的小细节：当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。当在类中自定义了构造函数后，默认的构造函数就没有了。
构造函数和一般函数在写法和运行上的不同：构造函数是在对象一建立就运行。给对象初始化。而一般方法是对象调用才执行，给是对象添加对象具备的功能。一个对
象建立，构造函数只运行一次，而一般方法可以被该对象调用多次。
什么时候定义构造函数呢？当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。
构造代码块。
作用：给对象进行初始化。
对象一建立就运行，而且优先于构造函数执行。
和构造函数的区别：
构造代码块是给所有对象进行统一初始化，
而构造函数是给对应的对象初始化。
构造代码快中定义的是不同对象共性的初始化内容。
this关键字：
当局部变量与成员变量的名字相同时，前者隐藏掉后者，要用到this，代表所在函数所属（本）对象的引用。简单的说哪个对象在调用this所在的函数，this就代
表哪个对象。
This语句：用于构造函数之间的调用（ps:构造一个人，只有姓名。构造另一个人，同时赋予姓名和年龄。就可以通过this（name）调用另一个构造函数——）
This（）语句只能定义在构造函数的第一行；因为初始化要先执行！！
static关键字：
静态：static。
用法：是一个修饰符，用于修饰成员(成员变量，成员函数。这些被修饰的都是共享数据).
当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用。类名.静态成员。
static特点：
1，随着类的加载而加载。 也就说：静态会随着类的消失而消失。说明它的生命周期最长。
2，优先于的对象存在 明确一点：静态是先存在。对象是后存在的。
3，被所有对象所共享
4，可以直接被类名所调用。
实例变量和类变量的区别：
1，存放位置。 类变量随着类的加载而存在于方法区中。实例变量随着对象的建立而存在于堆内存中。
2，生命周期：类变量生命周期最长，随着类的消失而消失。实例变量生命周期随着对象的消失而消失。
静态使用注意事项：
1，静态方法只能访问静态成员。非静态方法既可以访问静态也可以访问非静态。
2，静态方法中不可以定义this，super关键字。 因为静态优先于对象存在。所以静态方法中不可以出现this。
3，主函数是静态的。
静态有利弊：
利处：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。可以直接被类名调用。
弊端：生命周期过长。 访问出现局限性。(静态虽好，只能访问静态。)
静态应用：工具类
public class ArrayTool
{
private ArrayTool(){}
public static int getMax(int[] arr)
{
int max = 0;
for(int x=1; x<arr.length; x++)
{
if(arr[x]>arr[max])
max = x;
}
return arr[max];
}
public static int getMin(int[] arr)
{
int min = 0;
for(int x=1; x<arr.length; x++)
{
if(arr[x]<arr[min])
min = x;
}
return arr[min];
}
public static void selectSort(int[] arr)
{
for (int x=0; x<arr.length-1 ; x++ )
{
for(int y=x+1; y<arr.length; y++)
{
if(arr[x]>arr[y])
{
swap(arr,x,y);
}
}
}
}
public static void bubbleSort(int[] arr)
{
for (int x=0; x<arr.length-1 ; x++ )
{
for(int y=0; y<arr.length-x-1; y++)
{
if(arr[y]>arr[y+1])
{
swap(arr,y,y+1);
}
}
}
}
private static void swap(int[] arr,int a,int b)
{
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
public static void printArray(int[] arr)
{
System.out.print("[");
for(int x=0; x<arr.length; x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+", ");
else
System.out.println(arr[x]+"]");
}
}
}
静态代码块。
格式：
static {
静态代码块中的执行语句。
}
特点：随着类的加载而执行，只执行一次,并优先于主函数。 用于给类进行初始化的。
Person p = new Person("zhangsan",20);
该句话都做了什么事情？ 1，因为new用到了Person.class.所以会先找到Person.class文件并加载到内存中。 2，执行该类中的static代码块，如果有
的话，给Person.class类进行初始化。 3，在堆内存中开辟空间，分配内存地址。 4，在堆内存中建立对象的特有属性。并进行默认初始化。 5，对属性进行
显示初始化。 6，对对象进行构造代码块初始化。 7，对对象进行对应的构造函数初始化。 8，将内存地址付给栈内存中的p变量。
单例设计模式：解决一个类在内存只存在一个对象。
想要保证对象唯一。
1，为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象
2，还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。
3，为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。
饿汉式：一进内存，就已经创建好了对象。
class Single {
private Single(){} 1，将构造函数私有化。
private static Single s = new Single(); 2，在类中创建一个本类对象。
public static Single getInstance() { 3，提供一个方法可以获取到该对象。
return s;
}
}
懒汉式：对象是方法被调用时，才初始化，也叫做对象的延时加载。
class Single
{
private static Single s = null;
private Single(){}
public static Single getInstance()
{
if(s==null)
{
synchronized(Single.class) //多个对象同时调用这个方法的时候，出问题了，加上synchronized进行双重判断就可以达到高效和安全要求
{
if(s==null)
s = new Single();
}
}
return s;
}
}
继承：
继承：
1，提高了代码的复用性。
2，让类与类之间产生了关系。有了这个关系，才有了多态的特性。
注意：不要为了获取其他类的功能，简化代码才继承，一定要有继成 关系，所属关系是 is a；（不能为玩ipad管人家叫爹）。
3，Java语言中：java只支持单继承，不支持多继承；它用另一种体现形式来完成表示。多实现。 因为多继承容易带来安全隐患（父类多了， 功能相同的话，就会出现调
用不确定性）。
4，java支持多层继承。也就是一个继承体系。
5，简单一句话：查阅父类功能，创建子类对象使用功能。
6，子父类中的函数：当子类出现和父类一模一样的函数时， 当子类对象调用该函数，会运行子类函数的内容。 如同父类的函数被覆盖一样。
7，覆盖： 当子类出现和父类一模一样的函数时，当子类对象调用该函数，会运行子类函数的内容。如同父类的函数被覆盖一样。
子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败； 静态只能覆盖静态。
8，重载：只看同名函数的参数列表。重写：子父类方法要一模一样。
9，继承的了代码：利用复写提高了代码的扩展性
class Tel {
void show() {
System.out.println("number");
}
}
class NewTel extends Tel {
void show() {
super.show(); //System.out.println("number");
System.out.println("name");
System.out.println("pic");
}
}
10，字符类中的构造函数：
在对子类对象进行初始化时，父类的构造函数也会运行，那是因为子类的构造函数默认第一行有一条隐式的语句 super();super():会访问父类中空参数的构造函数。
而且子类中所有的构造函数默认第一行都是super();为什么子类一定要访问父类中的构造函数。因为父类中的数据子类可以直接获取。所以子类对象在建立时，需要先查看
父类是如何对这些数据进行初始化的。所以子类在对象初始化时，要先访问一下父类中的构造函数。如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式
来指定。注意：super语句一定定义在子类构造函数的第一行。
结论：子类的所有的构造函数，默认都会访问父类中空参数的构造函数。因为子类每一个构造函数内的第一行都有一句隐式super();当父类中没有空参数的构造函数
时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。当然：子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。子类中至少会有一
个构造函数会访问父类中的构造函数。
体会子父类的构造函数代码：
class Fu //extends Object
{
int num ;
Fu()
{
//super();
num= 60;
System.out.println("fu run");
}
Fu(int x)
{
System.out.println("fu ...."+x);
}
}
class Zi extends Fu
{
Zi()
{ super();
//super(4);
System.out.println("zi run");
}
Zi(int x)
{
this();
//super();
//super(3);
System.out.println("zi..."+x);
}
}
11，final：最终。作为一个修饰符，
可以修饰类，函数，变量。
被final修饰的类不可以被继承。为了避免被继承，被子类复写功能。
被final修饰的方法不可以被复写。
被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，也可以修饰局部变量。
内部类定义在类中的局部位置上是，只能访问该局部被final修饰的局部变量。
12，抽象类：abstract
当多个类中出现相同功能，但是功能主体不同，这是可以进行向上抽取。这时，只抽取功能定义，而不抽取功能主体。
特点：
抽象方法一定在抽象类中。
抽象方法和抽象类都必须被abstract关键字修饰。
抽象类不可以用new创建对象。因为调用抽象方法没意义。
抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。
抽象可以强迫子类去实现某些功能。
特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。
抽象类中是否有构造函数？：有，抽象类是一个父类，要给子类提供实例的初始化。
abstract 关键字，和哪些关键字不能共存：final：被final修饰的类不能有子类。而被abstract修饰的类一定是一个父类；private: 抽象类中的私有的抽象方法，
子类所知，就无法被复写，而抽象方法出现的就是需要被复写；如果static可以修饰抽象方法，那么连对象都省了，直接类名调用就可以了。可是抽象方法运
行没意义。
抽象类代码
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();//父类不知道怎么工作所以是abstract 那么类也是abstract的
}
class Manager extends Employee{
private int bonus;
Manager(String name,String id,double pay,int bonus){
super(name,id,pay);
this.bonus = bonus;
}
public void work() //强行让子类复写父类的抽象方法
{
System.out.println("manager work");
}
}
class Pro extends Employee{
Pro(String name,String id,double pay){
super(name,id,pay);
}
public void work(){
System.out.println("pro work");
}
}
模版方法设计模式
在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去。由该类的子类去完
成。
代码
abstract class GetTime {
public final void getTime() {
long start = System.currentTimeMillis();
uncode();
long end = System.currentTimeMillis();
ystem.out.println("毫秒："+(end-start));
}
public abstract void runcode();
}
class SubTime extends GetTime {
public void runcode() {
for(int x=0; x<4000; x++)
{
System.out.print(x);
}
}
}
class TemplateDemo {
public static void main(String[] args) {
SubTime gt = new SubTime();
gt.getTime();
}
}
接口（interface）：
格式特点：
接口中常见定义：常量，抽象方法；
接口中的成员都有固定修饰符。
常量：public static final 方法：public abstract
接口中的成员都是public的。
是不可以直接创建对象的，因为有抽象方法。子类对接口中的抽象方法全都覆盖后，子类才可以实例化。
接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。
接口的特点：
1、接口是对外暴露的规则。
2、接口是程序的扩展。
3、接口可以用来多实现。
4、接口与接口之间可以多继承，用,隔开
5、类与接口是实现，而且一个类在继承的同时实现多个接口。降低了耦合性（讲好规则之后，可以分拆，同时开工，模块式开发）
接口代码体现
interface Inter
{
public static final int NUM = 3;
public abstract void show();
}
interface InterA
{
public abstract void show();
}
class Demo
{
public void function(){}
}
class Test extends Demo implements Inter,InterA
{
public void show(){}
}
interface A{
void methodA();
}
interface B //extends A{
void methodB();
}
interface C extends B,A{
void methodC();
}
class D implements C{
public void methodA(){}
public void methodC(){}
public void methodB(){}
}
class InterfaceDemo
{
public static void main(String[] args) {
Test t = new Test();
System.out.println(t.NUM);
System.out.println(Test.NUM);
System.out.println(Inter.NUM);
} }
类和类之间的关系（除了继承还有聚集）
聚集：has a .
组合：结合更紧密，例如身体中的一部分（手、肺）。
聚合：一个球队有很多球员的关系。子父类中变量的特点：
多态：可以理解为事物存在的多种体现形态
多态的体现：父类的引用指向了自己的子类对象；父类的引用也可以接收自己的子类对象
多态的前提：必须是类与类之间有关系。要么继承，要么实现；通常还有一个前提：存在覆盖。
多态的好处：多态的出现大大的提高程序的扩展性。
多态的弊端：提高了扩展性，但是只能使用父类的引用访问父类中的成员。
多态的应用：
扩展性
abstract class Animal {
abstract void eat();
}
class Cat extends Animal {
public void eat() {
System.out.println("吃鱼");
}
public void catchMouse() {
System.out.println("抓老鼠");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("吃骨头");
}
public void kanJia() {
System.out.println("看家");
}
}
class Pig extends Animal {
public void eat() {
System.out.println("饲料");
}
public void gongDi() {
System.out.println("拱地");
}
}
class DuoTaiDemo
{
public static void main(String[] args)
{
//Animal c = new Cat(); //这就是转型
//c.eat();
Cat c = (Cat)a; //强制将父类的引用。转成子类类型。向下转型。
c.catchMouse();//我们能转换的是父类引用指向了自己的子类对象时，该引用可以被提升，也可以被强制转换。多态自始至
function(new Cat());//终都是子类对象在做着变化。
function(new Dog());
function(new Pig());
}
public static void function(Animal a)//Animal a = new Cat();
{
a.eat();
//a.catchMouse();
if(a instanceof Cat)//instanceof : 用于判断对象的类型。 对象 intanceof 类型(类类型 接口类型)
{
Cat c = (Cat)a;
c.catchMouse();
}
ese if(a instanceof Dog)
{
Dog c = (Dog)a;
c.kanJia();
}
}
}
多态非静态成员函数
在编译时期：参阅引用型变量所属的类中是否有调用方法。如果有，编译通过；如果没有则失败。
在运行时期：参阅所属的类中是否有调用的方法。
简单总结就是：编译看左边，运行看右边。
面试会遇到的问题：
多态中，成员变量的特点：无论编译还是运行，都参考左边（引用型变量所属的类）。
多态中，静态成员函数的特点：同上。因为先加载，不属于对象。
多态的主板示例：
PCI接口，主板、网卡、声卡、debug卡
接口开发模式，从第collection col = new ArrayList();//接口的引用指向子类对象。提高程序健壮性和扩展性
多态的扩展示例：
数据库的操作：
1）连接数据库 (JDBC Hibernate框架连接)
2）操作数据库（c r u d ）
3）关闭数据库连接
object：
超类，包含所有对象都有的功能。Java认为所有对象都具备比较性，equals方法比较的是哈希值。让类可以比较的话不用再定义新的功能，可以直接覆盖超类的
方法。
class Demo //extends Object
{
private int num;
Demo(int num)
{
this.num = num;
}
public boolean equals(Object obj)//Object obj = new Demo();
{
if(!(obj instanceof Demo))
return false;
Demo d = (Demo)obj;
return this.num == d.num;
}
/*
public boolean compare(Demo d)
{
return this.num==d.num;
}
*/
public String toString()
{
return "demo:"+num;
}
}
class Person
{
}
class ObjectDemo
{
public static void main(String[] args)
{
Demo d1 = new Demo(4);
System.out.println(d1);//输出语句打印对象时，会自动调用对象的toString方法。打印对象的字符串表现形式。
Demo d2 = new Demo(7);
System.out.println(d2.toString());
//Demo d2 = new Demo(5);
//Class c = d1.getClass();
}
}
内部类：
内部类的访问规则：
1、内部类可以访问外部类的成员（因为outer.this.成员变量），包括private的。
2、外部类要访问内部类，要先建立内部类对象（格式： 外部类.内部类 名字 = new 外部类.内部类（）；）。
3、内部类在外部类成员位置上时可以被private修饰，用 来封装。
4、内部类被static修饰后跟静态用法一样（不能访问非 静态变量、因为没有super和this）
5、当内部类中的定义了静态成员，该内部类必须是static
6、当外部类中的静态方法访问内部类时，内部类也必须 是static的
7、内部类中要访问局部变量，需要被声明为final
内部类什么时候用：
当描述事物时，事物的内部还有事物，该事物用内部类来描述（比如人类，人内有各种器官），因为内部类在使用外部类的内容
内部类定义在局部时：
1、不能被成员修饰符修饰。
2、可以直接访问外部类成员，因为还持有外部类引用，但是不可以访问局部变量，只能访问final修饰的局部类。
3、在其他的外部类中部内new出内部类
匿名内部类：
1、匿名内部类其实是内部类的简写格式。
2、定义匿名内部类的前提：内部类必须是继承一个类或者实现接口
3、匿名内部类格式：new 父类或者接口（）{定义子类内容}
4、匿名内部类就是匿名的子类对象，而且这个对象有点胖。可以理解为 带内容的对象。
5、匿名对象只能调用一次。
6、匿名内部类中的方法，最好不要超过三个。