---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------
面向对象：它是一种思想，是相对于面向过程而言！
(1)相对于面向过程而言的一种思想。面向过程：关注实现问题的过程。面向对象：关注实现问题的结果。(2)思想特点：A:是一种更符合人们思考习惯的思想B:把复杂的问题简单化了C:让我们从执行者变成指挥者
案例：把大象装进冰箱！、
把大象装进冰箱
面向过程：
class Test
{
public static void main(String[] args)
{
open();
in();
close();
}
public static void open()
{
System.out.println("打开冰箱门");
}
public static void in()
{
System.out.println("把大象装进去");
}
public static void close()
{
System.out.println("关闭冰箱门");
}
}
面向对象：
如何使我们的程序更符合面向对象呢
A:分析问题有哪些类
B:分析类有哪些成员
C:分析类与类的关系
class 大象
{
public void in()
{
System.out.println("把大象装进去");
}
}
class 冰箱
{
public void open()
{
System.out.println("打开冰箱门");
}
public void close()
{
System.out.println("关闭冰箱门");
}
}
class Test
{
public static void main(String[] args)
{
冰箱 b = new 冰箱();
b.open();
大象 d = new 大象();
d.in();
b.close();
}
}
类：类是一类事物的抽象对象：是该类事物的具体的存在
Car c=new Car（）；在计算机存储方式
构造方法(1)作用：通过new调用去创建对象,对对象的内容进行初始化。(2)格式：public 类名(参数...){...}格式特点：A:方法名与类名相同B:没有返回值类型C:没有返回值(3)注意事项A:如果一个类没有给出构造方法，系统会默认给出一个无参构造方法。B:如果一个类给出了构造方法，系统将不再提供无参构造方法。这个时候，如果你要使用无参构造方法，只能手动给出。推荐：任何时刻都自己手动给出无参构造方法。(4)构造的使用(给成员变量赋值) class Person{private String name;private int age;/*构造代码块。作用：给对象进行初始化。对象一建立就运行，而且优先于构造函数执行。和构造函数的区别：构造代码块是给所有对象进行统一初始化，而构造函数是给对应的对象初始化。
构造代码快中定义的是不同对象共性的初始化内容。
*/
{
//System.out.println("person code run");
cry();
}
Person()
{
System.out.println("A: name="+name+",,age="+age);
}
/**/
Person(String n)
{
name = n;
System.out.println("B: name="+name+",,age="+age);
//cry();
}
/*
public void setName(String n)
{
name = n;
}
public String getName()
{
return name;
}
*/
Person(String n,int a)
{
name = n;
age = a;
System.out.println("C: name="+name+",,age="+age);
//cry();
}
public void cry()
{
System.out.println("cry......");
}
}
class PersonDemo2
{
public static void main(String[] args)
{
Person p1 = new Person();
Person p2 = new Person("lisi");
//System.out.println(p2.getName());
//Person p3 = new Person("wnagu",10);
}
}
成员变量和局部变量的区别(1)在一个方法中使用一个变量的步骤：A:在局部范围找B:在成员范围找C:报错(2)区别A:位置成员变量在类中，方法外。局部变量在所属方法中。B:存储位置成员变量是随着对象的创建而存在，随着对象的消失而消失。在堆内存。
局部变量是随着方法的调用而存在，随着方法的调用完毕而消失。在栈内存。C:初始化成员变量有默认值。局部变量必须先赋值，再使用。D:作用域成员变量在类中的所有方法中都可以使用。局部变量只能在所属的方法中使用。匿名对象：没有名字的对象。 匿名对象使用方式一：当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化。 如果对一个对象进行多个成员调用，必须给这个对象起个名字。 匿名对象使用方式二：可以将匿名对象作为实际参数进行传递。封装(1)隐藏实现细节,提供公共的访问方式(2)特点：A:将变化隔离B:方便使用C:提高重用性D:提高安全性(3)在Java中如何体现：类,函数,还有就是通过private修饰成员变量。代码体现：private关键字 A:是一个修饰符。可以修饰成员变量,成员方法。 B:被私有修饰的内容只能在该类中使用。
private仅仅是封装的一种体现。/*private :私有，权限修饰符：用于修饰类中的成员(成员变量，成员函数)。私有只在本类中有效。
将age私有化以后，类以外即使建立了对象也不能直接访问。但是人应该有年龄，就需要在Person类中提供对应访问age的方式。
注意：私有仅仅是封装的一种表现形式。
之所以对外提供访问方式，就因为可以在访问方式中加入逻辑判断等语句。对访问的数据进行操作。提高代码健壮性。
成员变量和局部变量的区别(1)在一个方法中使用一个变量的步骤：A:在局部范围找B:在成员范围找C:报错(2)区别A:位置成员变量在类中，方法外。局部变量在所属方法中。B:存储位置成员变量是随着对象的创建而存在，随着对象的消失而消失。在堆内存。
局部变量是随着方法的调用而存在，随着方法的调用完毕而消失。在栈内存。C:初始化成员变量有默认值。局部变量必须先赋值，再使用。D:作用域成员变量在类中的所有方法中都可以使用。局部变量只能在所属的方法中使用。匿名对象：没有名字的对象。 匿名对象使用方式一：当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化。 如果对一个对象进行多个成员调用，必须给这个对象起个名字。 匿名对象使用方式二：可以将匿名对象作为实际参数进行传递。封装(1)隐藏实现细节,提供公共的访问方式(2)特点：A:将变化隔离B:方便使用C:提高重用性D:提高安全性(3)在Java中如何体现：类,函数,还有就是通过private修饰成员变量。代码体现：private关键字 A:是一个修饰符。可以修饰成员变量,成员方法。 B:被私有修饰的内容只能在该类中使用。
private仅仅是封装的一种体现。/*private :私有，权限修饰符：用于修饰类中的成员(成员变量，成员函数)。私有只在本类中有效。
将age私有化以后，类以外即使建立了对象也不能直接访问。但是人应该有年龄，就需要在Person类中提供对应访问age的方式。
注意：私有仅仅是封装的一种表现形式。
之所以对外提供访问方式，就因为可以在访问方式中加入逻辑判断等语句。对访问的数据进行操作。提高代码健壮性。
*/
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);
//p.speak();
}
}
his(1)代表当前类的一个对象的引用。(2)this的使用场景：A:局部变量隐藏成员变量B:构造方法间相互调用使用格式：this.成员变量this.成员方法()this(参数) -- 调用本类的其他构造。this(1)代表当前类的一个对象的引用。(2)this的使用场景：A:局部变量隐藏成员变量B:构造方法间相互调用使用格式：this.成员变量this.成员方法()this(参数) -- 调用本类的其他构造。
class Person
{
private String
private int age;
Person(int age)
{
this.age = age;
}
Person(String name)
{
this.name = name;
}
Person(String name,int age)
{
this.name = name;
this.age = age;
}
public void speak()
{
System.out.println("name="+this.name+"...age="+this.age);
this.show();
}
public void show()
{
System.out.println(this.name);
}
static(1)是一个关键字，可以修饰成员变量和成员方法(2)特点：A:随着类的加载而加载。B:优先于对象存在。C:被所有对象共享。D:可以被类名调用。(3)静态方法和非静态方法的使用A:静态方法a:静态成员变量b:静态成员方法
B:非静态方法a:非静态成员变量b:非静态成员方法c:静态成员变量d:静态成员方法(4)静态变量和非静态变量的区别?A：生命周期静态随着类的加载而加载，随着类的消失而消失。非静态随着对象的创建而存在，随着对象的消失而消失。
B：存储位置静态是存储在方法区中的静态区。(方法区：方法区,静态区,代码区,常量池)非静态是存在堆中。
C：调用方式静态可以类名调用，也可以对象名调用。非静态只能对象名调用。
D：理解不同静态修饰的内容是被所有对象共享的。非静态的内容是每个对象特有的。static(1)是一个关键字，可以修饰成员变量和成员方法(2)特点：A:随着类的加载而加载。B:优先于对象存在。C:被所有对象共享。D:可以被类名调用。(3)静态方法和非静态方法的使用A:静态方法a:静态成员变量b:静态成员方法
B:非静态方法a:非静态成员变量b:非静态成员方法c:静态成员变量d:静态成员方法(4)静态变量和非静态变量的区别?A：生命周期静态随着类的加载而加载，随着类的消失而消失。非静态随着对象的创建而存在，随着对象的消失而消失。
B：存储位置静态是存储在方法区中的静态区。(方法区：方法区,静态区,代码区,常量池)非静态是存在堆中。
C：调用方式静态可以类名调用，也可以对象名调用。非静态只能对象名调用。
D：理解不同静态修饰的内容是被所有对象共享的。非静态的内容是每个对象特有的。
class StaticCode
{
int num = 9;
StaticCode()
{
System.out.println("b");
}
static
{
System.out.println("a");//静态代码块给类初始化
}
{
System.out.println("c"+this.num);//构造代码块，给对象（本类中的）初始化的
}
StaticCode(int x)//构造函数，给对应对象初始化的
{
System.out.println("d");
}
public static void show()
{
System.out.println("show run");
}
}
class StaticCodeDemo
{
static
{
//System.out.println("b");
}
public static void main(String[] args)
{
new StaticCode(4);//a c d
}
static
{
}
}
制作文档(1)把类文件加入文档注释(2)使用javadoc命令即可javadoc -d doc -version -author ArrayTools.java
使用帮助文档(API)(1)使用步骤A:打开文档。B:点击显示 -- 找到索引。C:知道你要使用的类名。D:在索引哪里输出类名,回车。E:看包名如果是java.lang包，就可以直接使用类。如果不是java.lang包，就得导入包。如何导入呢：格式：import xxx.xxx.类名;F:看构造方法有构造方法：学习构造方法并创建对象。没有构造方法：它的成员都是静态的。G:使用功能通过对象调用方法。
看左边：是否静态，以及返回值类型。看右边：方法名及参数。
代码块(1)就是用{}括起来的一段代码作用：可以限定代码的作用域,提高效率。
(2)分类：局部代码块：在方法中。
作用：尽早的让变量消失，提高效率。
构造代码块：在成员位置上。作用：针对多个构造中相同的内容，用它实现。一般不用。
静态代码块：在构造代码块上加了static修饰
作用：数据库的连接。只执行一次。(3)静态代码块,构造代码块,构造方法的执行顺序：静态代码块 -- > 构造代码块 -- > 构造方法
静态代码块只执行一次，构造代码块每次在构造执行的时候，都执行。 Person p = new Person()在内存中的执行步骤。(理解)A:把Person.class加载到内存中。B:在栈内存给p变量开辟空间。C:在堆内存给Person对象开辟空间。D:对成员变量进行默认初始化。E:对成员变量进行显示初始化。F:通过构造方法对成员变量进行初始化。 (如果有构造代码块，先用构造代码块对成员变量初始化)G:对象才创建完毕。H:把对象的内存地址值给p变量。
class Person
{
String name;
int age;
}
class Student extends Person
{
void study()
{
System.out.println("good study");
}
}
class Worker extends Person
{
void work()
{
System.out.println("good work");
}
}
class ExtendsDemo
{
public static void main(String[] args)
{
Student s = new Student();
s.name = "zhagnsan";
}
}
父类：超类，基类。子类：派生类。成员特点：(理解)A:成员变量在子类的方法中使用一个变量：a:在子类局部范围找，有就使用b:接着在子类成员范围找，有就使用c:再接着在父类的成员范围找，有就使用d:报错。B:构造方法子类的构造方法执行的时候，会首先去执行父类的构造方法。
注意：当父类没有无参构造的时候，子类要么用super调用父类带参数构造，
要么使用this调用本身的其他构造。
Object类：是所有类的超类，任何类都直接 或者间接继承自Object类。super 代表父类的存储空间。可以使用父类的成员。成员变量：super.成员变量成员方法：super.成员方法()构造方法：super(参数...)C:成员方法当子类出现和父类一模一样的方法时，父类的方法就会被子类覆盖调用。这种情况被称为方法的重写。(覆盖，重写，复写)
注意：a:父类私有的方法不能被重写。b:子类重写父类方法时，访问权限一定要大于等于父类权限。c:静态只能重写静态。(不属于对象的范畴)
用子类对象调用方法时：a:在子类中找方法，有就使用。b:在父类中找方法，有就使用。c:报错。
this和super的区别?this：当前类的对象的引用。super：父类的存储空间标识。
作用：this的使用：this(...)this.成员变量this.成员方法()
super的使用：super(...)super.成员变量super.成员方法() fianl关键字(1)是一个修饰符，表示最终的意思。(2)作用：final:修饰符，表示最终的意思。它可以修饰类：被修饰的类不能被继承。它可以修饰成员变量：被修饰的变量就是常量。定义常量。它可以修饰成员方法：被修饰的方法不能被子类重写。 抽象类(1)多个类中的方法声明一样，但是方法体不一样，针对这种情况，]我们只抽取方法声明， 而只有方法声明没有方法体的方法就是抽象方法。用abstract表示。 如果一个类中有抽象方法，这个类必须定义为抽象类。(2)抽象类的特点：A:一个类中如果有抽象方法，这个类必须定义为抽象类。 一个抽象类中可以没有抽象方法，这样的类的意义是为 了不让别人直接创建对象。B:一个类继承一个抽象类，要么全部实现父类的抽象方法，要么自己也是抽象类。C:抽象类不能被实例化。(3)抽象类的成员特点：A:成员变量可以是变量，也可以是常量B:构造方法有构造方法，用于子类实例化使用C:成员方法可以是抽象方法，也可以是非抽象方法abstract不能和哪些关键字共存？final:final修饰的方法不能被重写，而abstract修饰的方法必须被重写，冲突。static:static修饰的方法可以直接被类名调用，而调用一个抽象方法没有意义。private:private修饰的方法不能被重写，而abstract修饰的方法必须被重写，冲突。模版方法 在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分， 那么这时就将不确定的 部分暴露出去。由该类的子类去完成。 什么是模版方法呢？ 在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分， 那么这时就将不确定的部分暴露出去。由该类的子类去完成。 接口(1)当抽象类中的方法都是抽象的时候，java就提供了一种新的表现形式：接口。(2)格式：父接口：interface Inter{}
子类：class InterImpl implements Inter{}(3)接口的特点：A:不需要被abstract修饰。B:类实现接口,可以单实现,还可以多实现。C:接口可以接口接口,可以单继承，也可以多继承。(4)抽象类和接口的区别:A:成员的区别抽象类：成员变量：可以是变量，也可以是常量。构造方法：有构造方法，用于子类实例化使用。成员方法：可以是抽象的，也可以是非抽象的。
接口：成员变量：只能是常量。 默认修饰符：public static final成员方法：只能是抽象的。 默认修饰符：public abstract
推荐：默认修饰符请自己永远手动给出。
B:类和接口的关系区别类与类：继承关系,只能单继承。可以多层继承。
类与接口：实现关系,可以单实现,也可以多实现。类还可以在继承一个类的同时实现多个接口。
接口与接口：继承关系,可以单继承,也可以多继承。
C:体现的理念不同抽象类里面定义的都是一个继承体系中的共性内容。抽象类被继承：is a关系。xx是yy的一种。接口里面定义的是一个体系的扩展内容。接口被实现：like a关系。xx像yy的一种。
多态(1)同一个对象，在不同时刻表现出来的不同状态。(2)前提：A:有继承或者实现关系。B:有方法的重写。C:有父类(接口)的引用指向子类对象。(3)多态中的成员使用特点：父类引用指向子类对象Fu f = new Zi();System.out.println(f.num);f.show();
A:成员变量编译看左边，运行看左边。B:成员方法编译看左边，运行看右边。
(4)多态中的转型：A:向上转型把子类对象赋值给父类(接口)的引用B:向下转型把父类(接口)的引用强制转换成子类对象(5)多态的好处及弊端：A:好处提高了程序可维护下和可扩展性。开闭原则：对扩展开放，对修改关闭。B:弊端不能使用子类特有内容。要想使用，要么向下转型，要么重新创建子类对象。(6)多态的三种形式：A:具体的类多态B:抽象类多态C:接口多态Object类 (1)是类结构的根类，所有类都直接或者间接的继承自Object类。(2)方法：public String toString():返回对象的字符串表示形式。类名+@+地址值的十六进制public int hashCode():返回对象的哈希值。public boolean equals(Object obj):默认比较对象的地址值。(3)一般，我们会重写一个类的toString()和equals()方法A:toString():默认的toString()的值没有意义。B:equals():比较的是地址值，也是没有意义。
例：
class Student
{
private String name;
private int age;
//...get/set
public String toString()
{
//name:null,age:0 -- 默认
return "name:"+name+",age:"+age;
}
//同时比较一个人的名字和年龄是否相同
public boolean equals(Object obj)
{
//提高效率
if(this == obj)
{
return true;
}
//提高健壮性
if(!(obj instranceof Student))
{
return false;
}
//强制类型转换
Student s = (Student)obj;
return this.age == s.age && this.name.equals(s.name);
}
}
(4)判断一个对象是否是某个类的对象，用instanceof关键字：格式：对象 instanceof 类名 内部类(1)把类B定义在类A中，类B就被称为内部类。(2)为什么要是内部类呢?内部的访问特点A:内部类可以直接使用外部类成员，包括私有。B:外部类使用内部类必须创建对象使用。(3)内部的分类：成员位置：类一进去就定义类局部位置：方法内部定义(4)成员内部类：class Outer{class Inner{public void show(){}}}
//未用静态修饰或者private修饰。Outer.Inner oi = new Outer().new Inner();oi.show();
用静态修饰后：Outer.Inner oi = new Outer.Inner();oi.show();
一般来说，内部类都会使用private修饰。(5)局部位置：匿名内部类：本质是一个对象。
前提：存在这个一个类或者接口。
格式：new 类或者接口名(){重写方法();};
本质：是继承类或者实现了接口的子类的匿名对象。一般来说，应该是实现接口，并且，接口中一般都是只有一个方法。 异常(1)异常：程序出现的非正常情况。(2)异常体系结构：Throwable|--Error 错误,严重的错误。我们处理不了的。|--Exception 异常。|--RuntimeException 在运行期间出现的问题，这种情况一般都是改程序。|--非RuntimeException 编译期间异常,这才是我们需要处理的问题。举例：Error:地震了,内存不够,非典Exception:感冒了,嗓子不好(3)异常的默认处理方案：把异常的信息显示在控制台。包括：异常类名，异常原因，异常的位置。
Throwable的三个方法：toString():把类名: 异常原因返回。getMessage():获取异常原因printStackTrace():打印异常信息
(4)异常的处理方案：A:try...catch...finally格式：try{可能有问题的代码}catch(){解决问题}finally{释放资源}B:throws throwthrows 异常类名throw 异常对象名 throws和throw的区别?A:throws跟在方法后面的，其后跟的是类名。 throws后面如果是编译期间异常，将来调用的时候，也要抛出或者处理。 throws后面如果是运行期间异常，将来可以不处理。B:throw用在方法体中，其后跟的是对象名。 throw后面如果是编译期间异常，必须在方法上用throws抛出该异常类名。 throw后面如果是运行期间异常，可以不用throws抛出。 自定义异常A:创建一个类继承自Exception或者RuntimeException。B:建议在类中提供一个带参构造方法，调用父亲的带参构造方法。 将来可以通过getMessage()获取到异常原因 编译期间异常和运行期间异常的区别A:编译期间异常是必须处理的，否则程序不能通过编译。 如果把编译期间异常给抛出了，将来还是要处理的。B:在运行时候才发生的问题，在编译期间是可以不用处理的。 运行时期的异常，不用处理。 包及导包(1)包：其实就是文件夹。 作用：用于区分类以及进行相同类型的类的管理。 定义包：package 包名1.包名2...;
(2)带包的编译和运行A:写代码B:编译方案1：手动方法直接编译手动建包把class文件扔到包里面方式2：自动方法javac -d . PackageDemo.java会自动给你创建包，并把class文件扔到这个包里。C:运行直接运行，但是需要带类的全路径名
java cn.itcast.PackageDemo(3)导入包：import 包名1.包名2....类名;(4)package,import,class的先后顺序问题package -- import -- class