-----------android培训、java培训、java学习型技术博客、期待与您交流！------------
面向对象
面向对象思想概述：面向对象的思想特点：面向对象是基于面向过程的编程思想，它强调的是对象，然后由对象去调用功能。
是一种更符合我们思想习惯的思想；
可以将复杂的事情简单化；
将我们从执行者变成了指挥者；
面向对象的开发：就是不断的创建对象，使用对象，指挥对象做事情。
面向对象的设计：其实就是在管理和维护对象之间的关系。
面向对象的特征：封装，继承，多态。
类与对象的关系：
类有以下三部分组成：Java中最基本的单位是类，类是一组相关的属性和行为的集合，而类的对象是该类事物的具体体现。
成员变量：就是该事物的属性；
构造方法；
成员方法：就是事物的行为；
类的使用：
创建对象
类型 对象名 = new 类名();
调用成员变量：对象名.成员变量;
调用成员方法：对象名.成员方法;
成员变量和局部变量的区别：
在类中的位置不同
成员变量 类中方法外；
局部变量 方法内或者方法声明上；
在内存中的位置不同
成员变量 堆内存；
局部变量 栈内存；
生命周期不同
成员变量 随着对象的存在而存在，随着对象的消失而消失；
局部变量 随着方法的调用而存在，随着方法的调用完毕而消失；
初始化值不同
成员变量 有默认的初始化值；
局部变量 没有默认的初始化值，必须先定义，赋值，才能使用；
形式参数的问题：
形式参数是类名的调用：基本类型：形式参数的改变不影响实际参数；
引用类型：形式参数的改变直接影响实际参数；
当一个方法的形式参数是一个类类型的时候，这里其实需要的是该类的对象。
匿名对象
匿名对象就是没有名字的对象。
匿名对象的应用场景：
对象仅调用方法一次的时候；
匿名对象可以作为实际参数传递；
使用匿名对象的好处：
匿名对象调用完毕就是垃圾，可以被垃圾回收器回收。
封装
概述：隐藏对象的属性和实现细节，仅对外提供公共的访问方式。
封装好处：
提高了代码的复用性；
提高了安全性；
private关键字
是一个权限修饰符；
可以修饰成员变量和成员方法；
被private修饰的成员只在本类中才能访问。
this关键字
构造方法this代表所在类的对象引用，即方法被哪个对象调用，this就代表那个对象。
使用场景：
解决局部变量隐藏成员变量。
概述：给对象的数据进行初始化。
格式：
方法名与类名相同；
没有返回值类型，包括void；
没有具体的返回值。
使用中的注意事项：
若果不自行写出构造方法，系统会给出默认构造方法；
若果自行写出构造方法，系统将不再提供；
构造方法也可以重载。
一个基本类的标准代码写法举例：
<span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;">//创建一个学生类，有姓名和年龄属性 class Student { private String name; private int age; public Student() { } public Student(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } } public class StudentDemo { public static void main(String[] args) { //通过setXxx给成员变量赋值 Student s = new Student(); s.setName("刘德华"); s.setAge(50); System.out.println(s.getName()+"---"+s.getAge()); //通过构造方法给成员变量赋值 Student s2 = new Student("刘德华",50); System.out.println(s2.getName()+"---"+s2.getAge()); } }</span></span></span></span></span></span></span></span></span></span></span></span>
上述代码中，类的初始化语句Student s = new Student();在内存中依次做了以下事情：
a:加载Student.class文件进内存
b:在栈内存为s开辟空间
c:在堆内存为学生对象开辟空间
d:对学生对象的成员变量进行默认初始化
e:对学生对象的成员变量进行显示初始化
f:通过构造方法对学生对象的成员变量赋值
g:学生对象初始化完毕，把对象地址赋值给s变量
static关键字
static可以修饰成员变量，还可以修饰成员方法。
特点：
a:随着类的加载而加载；
b:优先于对象存在；
c:被类的所有对象共享；
d:可以通过类名调用，
static关键字的注意事项：
在静态方法中是没有this关键字；
静态方法只能访问静态的成员变量和静态的成员方法。
帮助文档的制作
A:写一个工具类；
B:对这个类加入文档注释；
C:用工具解析文档注释；（javadoc工具）
格式：javadoc -d 目录 -author -version 工具类名.java
代码块
概述：在Java中，使用{}括起来的代码被称为代码块，根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块。
局部代码块：在方法中出现，限定变量生命周期，及早释放，提高内存利用率。
构造代码块：在类中方法外出现，多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行。
静态代码块：在类中的成员位置，用static修饰，用于给类进行初始化，在加载的时候就执行，并且只值执行一次。
继承
概述：
多个类中存在相同的属性和行为时，将这些内容抽取到一个单独的类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。通过extends关键字可以实现类与类的继承。
格式：class 子类名 extends 父类名 {}
继承的好处：
提高了代码的复用性；
提高了代码的维护性；
让类与类之间产生了关系，是多态的前提。（这同样也是一个弊端，使类的耦合性增强）
继承的特点：
Java中只支持单继承，不支持多继承；但Java支持多层继承。
继承的注意事项：
父类的私有成员子类不能继承；
子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法；
不要为了部分功能而去继承。
在子类方法中访问一个变量时，程序的执行顺序
super关键字
this代表本类对应的引用，super代表父类存储空间的标识(可以理解为父类引用，可以操作父类的成员)。
使用方法：
A:访问成员变量：
this.成员变量 调用本类的成员变量；
super.成员变量 调用父类的成员变量；
B:调用构造方法：
this(...) 调用本类的构造方法；
super(...) 调用父类的构造方法；
C:调用成员方法：
this.成员方法 调用本类的成员方法；
super.成员方法 调用父类的成员方法；
继承中构造方法的关系
子类中所有的构造方法都会默认访问父类的无参构造方法
原因：每一个构造方法的第一条语句默认都是super()，因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化。
当父类中没有无参构造方法，有两条解决方案：
继承中成员方法的关系a:子类通过super(...)去调用父类其他的带参的构造方法；
b:子类通过this(...)去调用本类的其他构造方法；
使用中本类的其它构造必须首先访问了父类构造，
super(...)或this(...)必须出现在第一条语句上，否则，父类数据会多次初始化，
通过子类对象去访问一个方法时，程序会先在子类中找，然后在父类中找；
方法重写
概述：子类中出现了和父类中一模一样的方法声明。（包括返回值类型，方法名，参数列表）
方法重写的注意事项：
a:父类中的私有方法不能被重写；
b:子类重写父类方法时，访问权限不能更低；
c:父类的静态方法，子类也必须通过静态方法重写；
final关键字
是最终的意思，可以修饰类，成员变量，成员方法。
修饰类，类不能被继承；
修饰方法，方法不能被重写；
修饰变量，变量就不能被重新赋值，因为这个变量其实是常量。
final修饰局部变量的问题
修饰基本类型：基本类型的值不能发生改变；
修饰引用类型：引用类型的地址值不能发生改变，但是，该对象的堆内存的值是可以发生改变的。
final修饰变量的初始化时机：在构造方法完毕前。
多态
概述：某一个事物，在不同时刻表现出来的不同状态。
格式：Fu f = new Zi();
多态的前提：
有继承关系；
有方法重写；
有父类引用指向子类对象。
多态中的成员访问特点：
A:成员变量：编译看左边，运行看左边；
B:构造方法：创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化；
C:成员方法：编译看左边，运行看右边；
D:静态方法：编译看左边，运行看左边；（静态和类相关，算不上重写）
多态的好处：
提高了程序的维护性；
提高了程序的扩展性；
多态的弊端：
不能访问子类的特有功能。
但使用如下方法能消除此弊端：
A:创建子类对象调用方法。（此方法浪费内存）
B:把父类的引用强制转换为子类的引用。（向下转型）
对象间的转型：
向上转型：Fu f = new Zi();
向下转型：Zi z = (Zi) f;
抽象类
抽象类的特点：概述：在Java中，所有的对象都是通过类来描述的，但如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
抽象类和抽象方法必须用abstract关键字修饰；
抽象方法不能有方法体；
抽象类不一定有抽象方法，有抽象方法的类一定是抽象类；
抽象类不能实例化，因为它不是具体的，创建抽象类的对象只能通过多态方法来实现，由具体的子类实例化；
抽象类有构造方法，用于子类访问父类数据的初始化；
抽象类的子类如果也是抽象的，它可以不用重写父类方法，但子类如果是具体类，它必须重写父类的所有抽象方法。
抽象类的成员特点：
成员变量：
可以是变量，也可以是常量；
构造方法：
有构造方法，但是不能实例化；
成员方法：
可以有抽象方法，作用是限定具体的子类必须完成的动作，也可以有非抽象方法，子类可继承，提高代码的复用性。
注意事项：
abstract不能和以下关键字共存：
private，final，static
接口
接口的特点：概述：接口时一系列方法特征的集合，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的功能。
接口用关键字interface表示；
格式：interface 接口名{}
类实现接口用implements表示；
格式：class 类名 implements 接口名{}
接口不能实例化，实例化方式只能通过多态方式，由具体的子类实例化。
接口的子类：
可以是抽象类，但意义不大；
可以是具体类，但要重写接口中的所有抽象方法。
接口的成员特点：
成员变量：只能是常量，并且是静态的，它的默认修饰符是public static final；
类、接口之间的关系：构造方法：接口没有构造方法；
成员方法：只能是抽象方法，它的默认修饰符是public abstract
抽象类和接口的区别：类与类：可以是继承关系，只能单继承，可以多层继承；
类与接口：可以是实现关系，可以单实现，也可以多实现，并且还可以在继承一个类的同时实现多个接口。
接口与接口：可以是继承关系，单继承、多继承都可。
成员区别；
关系区别；
设计理念区别：
抽象类：被继承体现的是“is a”的关系，抽象类中定义的是该继承体系的共性功能。
接口：被实现体现的是“like a”的关系，接口中定义的是该继承体系的扩展功能。
以下是类、抽象类和接口的综合演示
<span style="font-size:14px;"><span style="font-size:14px;">//定义一个玩篮球接口 interface Basketball { public abstract void playBasketball(); } //定义一个属性为人的抽象类 abstract class Person { private String name; private int age; public Person() {} public Person(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public void sleep() { System.out.println("每天睡觉八小时"); } public abstract void eat(); } //定义一个属性为学生的抽象类，它继承自抽象人类 abstract class Student extends Person{ public Student() {} public Student(String name,int age) { super(name,age); } public abstract void study(); } //定义一个属性为老师的抽象类，它继承自抽象人类 abstract class Teacher extends Person{ public Teacher() {} public Teacher(String name,int age) { super(name,age); } public abstract void teach(); } //定义一个属性为中国学生的具体类，它继承抽象学生类，实现玩篮球接口 class ChineseStudent extends Student implements Basketball{ public ChineseStudent() {} public ChineseStudent(String name,int age) { super(name,age); } public void eat() { System.out.println("中国学生吃饭用筷子"); } public void study() { System.out.println("中国学生学习Java"); } public void playBasketball() { System.out.println("中国学生爱玩篮球"); } } //定义一个属性为美国学生的具体类，它继承抽象学生类，实现玩篮球接口 class AmericanStudent extends Student implements Basketball{ public AmericanStudent() {} public AmericanStudent(String name,int age) { super(name,age); } public void eat() { System.out.println("美国学生吃饭用刀叉"); } public void study() { System.out.println("美国学生学习Java"); } public void playBasketball() { System.out.println("美国学生爱玩篮球"); } } //定义一个属性为中国老师的具体类，它继承抽象老师类 class ChineseTeacher extends Teacher{ public ChineseTeacher() {} public ChineseTeacher(String name,int age) { super(name,age); } public void eat() { System.out.println("中国老师吃饭用筷子"); } public void teach() { System.out.println("中国老师教Java"); } } //定义一个属性为美国老师的具体类，它继承抽象老师类 class AmericanTeacher extends Teacher{ public AmericanTeacher() {} public AmericanTeacher(String name,int age) { super(name,age); } public void eat() { System.out.println("美国老师吃饭用刀叉"); } public void teach() { System.out.println("美国老师教Java"); } } public class PersonDemo { public static void main(String[] args) { //创建抽象类对象调用方法，不能调用接口中的玩篮球方法 Student cs = new ChineseStudent(); cs.setName("刘德华"); cs.setAge(30); cs.eat(); cs.sleep(); cs.study(); //创建具体类对象，所有方法都能调用 ChineseStudent cs2 = new ChineseStudent("王力宏",29); cs2.eat(); cs2.sleep(); cs2.study(); cs2.playBasketball(); //创建接口对象，只能调用接口中的玩篮球方法 Basketball as = new AmericanStudent("迈克尔",20); as.playBasketball(); //创建具体类对象，所有方法都能调用 ChineseTeacher ct = new ChineseTeacher("孔子",60); ct.eat(); ct.sleep(); ct.teach(); //创建抽象类对象调用方法 Teacher at = new AmericanTeacher("柏拉图",59); at.eat(); at.sleep(); at.teach(); } }</span></span>
形式参数是引用类型的问题
返回值是引用类型的问题形式参数是类名：需要的是该类的对象；
形式参数是抽象类：需要的是该抽象类的子类对象；
形式参数是接口：需要的是该接口的实现类对象；
返回值是类名：返回的是该类的对象；
返回值是抽象类：返回的是该抽象类的子类对象；
返回值是接口：返回的是该接口的实现类对象；
包
概述：包其实就是文件夹。
作用：对类进行分类管理。
定义格式：
package 包名;
多级包用.分开即可。
注意事项：
package语句必须是程序的第一条可执行的代码；
package语句在一个java文件中只能有一个；
如果没有package，默认表示无包名；
带包的类的编译和运行
A:javac编译的时候带上-d即可；
javac -d . 测试类名.java
B:通过java命令执行；（需要带包名称的执行）
导包
格式：import 包名;
这种方式是导入到类的名称。
权限修饰符
不同修饰符的可应用场景：
内部类
概述：把类定义在其他类的内部，这个类就被称为内部类
内部类的访问特点：
内部类可以直接访问外部类的成员，包括私有；
外部类要访问内部类的成员，必须创建对象；
按照内部类在类中定义的位置不同，可以分为成员内部类和局部内部类。
成员内部类：
外界创建对象的方式：
外部类名.内部类名 对象名 = 外部类对象.内部类对象;
成员内部类的常见修饰符：
private：为了保证数据的安全性，限制外部类以外的成员访问。
static：为了方便访问数据，（静态内部类访问的外部数据必须用静态修饰）
成员内部类被静态修饰后的访问方式是：
格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();
静态成员内部类的成员方法被静态修饰后的访问方式也可以是：
格式：外部类名.内部类名.方法名;
局部内部类：
特性：
可以直接访问外部类的成员；
可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能；
局部内部类访问局部变量必须用final修饰；
匿名内部类：
概述：就是内部类的简化写法。
前提：存在一个类、抽象类或者接口，然后匿名内部类去继承该类或实现该接口。
格式：
new 类名或接口名() {重写方法;}
本质：是一个继承了类或者实现了接口的子类的匿名对象。
150
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
