面向对象思想
概念
面向对象程序设计（Object Oriented Programming，OOP）是一种计算机编程架构。OOP的一条基本原则是计算机程序由单个能够起到子程序作用的单元或对象组合而成。OOP达到了软件工程的三个主要目标：重用性、灵活性和扩展性。OOP=对象+类+继承+多态+消息，其中核心概念是类和对象。
类和对象
类
类是对现实生活中一类具有共同特征的事物的抽象（ Java语言最基本单位，可以理解为模板或者设计图纸）
定义类
形式：class 类名 {}
定义类名时遵守大驼峰命名规则(XxXxXx)
对象
对象是类的具体的实现，每个对象具有三个特点。
对象的状态：描述对象的基本特征（成员变量）
对象的行为：描述对象的功能（成员方法）
对象的标识：对象在内存中都有一个唯一的地址
创建对象
形式：类型 变量名 = new 类型 （）;
定义变量名时遵守小驼峰命名规则(xxXxXx)
类和对象的关系
对象在内存的存储
封装
概念
封装即隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别。
特点
使用private关键字修饰属性，使其私有化，想要访问或修改，只能使用公共的get()和set()方法。
优点
提高安全性（属性私有化）
提高重用性（提取共性代码）
程序演示
public class Student {
//String name;
//把属性隐藏起来
private String name;
//设置公共的赋值方法
public void setName(String n){
name=n;
}
//设置公共的取值方法
public String getName(){
return name;
}
int age;
}
class StDemo{
public static void main(String[] args) {
Student s = new Student();
//不能访问私有的
//s.name="zhangsan";
//System.out.println(s.name);s
//利用setXxx()给属性赋值
s.setName("zhangsan");
//利用getXxx()给属性取值
System.out.println(s.getName());
}
}继承
概念
继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的属性和方法，或子类从父类继承方法，使得子类具有父类相同的行为
特点
1、 使用extends关键字
2、 相当于子类把父类的功能复制了一份
3、 java只支持单继承
4、 继承可以传递（爷爷，儿子，孙子的关系）
5、 不能继承父类的私有成员
6、 继承多用于功能的修改，子类可以拥有父类的功能的同时，进行功能拓展
7、 像是is a 的关系
优点
提高父类代码的复用性,减少子类代码的编写,提高开发效率
程序演示
public class TTT {
public static void main(String[] args) {
Zi zi = new Zi();
zi.speak();
System.out.println(zi.skin);
System.out.println(zi.addr);
}
}
class Fu{
String skin="黄种人";
String addr="大成都";
public void speak(){
System.out.println("Fu...speak()");
}
}
//通过extends和父类发生继承关系
//所有父类的功能，子类都可以继承过来，注意不能是private的
class Zi extends Fu{
//什么都不写，能不能把父亲的内容复制一份出来
}多态
概念
多态主要是指同一个对象，在不同时刻，代表的形象不一样，指的是对象的多种形态。
特点
1、 多态的前提是继承+方法的重写
2、 父类引用指向子类对象,如：Animal a = new Dog();//Dog extends Animal
3、 多态中，编译看左边，运行看右边
使用特点
1、成员变量：使用的是父类的
2、成员方法：由于存在重写现象所以使用的是子类的
3、静态成员：随着对象而存在，谁调用的就返回谁的
优点
做出通用编程,本质上就是不关心具体的子类的类型,屏蔽了子类之间的不同,可以把子类当做父类来看
提高程序的扩展性和可维护性
程序演示
public class p {
public static void main(String[] args) {
Animal an = new Dog();//父类引用指向子类对象--把右面的小的，给了左面大的。相当于从小到大的过程，向上造型。
an.eat();//只可以用父类的功能，这就统一了调用的标准
//狗吃肉,由于eat()发生了重写，所以父类方法被覆盖掉了
}
}
class Animal{
public void eat(){
System.out.println("大小通吃");
}
}
class Dog extends Animal{
public void kanjia(){
System.out.println("狗可以看家");
}
public void eat(){
System.out.println("狗吃肉");
}
}构造方法
概念
构造方法是一种特殊的方法，它是一个与类同名且返回值类型为同名类类型的方法。对象的创建就是通过构造方法来完成，其功能主要是完成对象的创建或者对象的初始化。当类实例化一个对象时会自动调用构造方法。
构造方法和其他方法一样也可以重载。
形式与特点
形式
修饰符 类名 (含参或无参) {...}
特点
定义类时，系统会默认该类拥有一个无参构造，但当我们定义一个含参构造后，无参构造不再默认拥有，需手动定义。
程序演示
public class Constructor {
String name;
//当存在一个含参的构造方法时，无参构造将不再自动生成...
//public Constructor(){}
//含参构造
public Constructor(String n){
name=n;
}
void eat(){
System.out.println("Constructor.eat()");
}
}
class cc{
public static void main(String[] args) {
//注释掉无参的构造也可以运行，说明系统会自动提供一个无参的构造方法
Constructor c1 = new Constructor();
c1.eat();
//c1是引用变量，引用的是对象的地址值。
//根据地址值找到对象，并获取对象的数据
Constructor c2 = new Constructor("张三");
System.out.println(c2.name);
}
}重载与重写(Overload&Override)
1、重载：是指同一个类中的多个方法具有相同的名字,但这些方法具有不同的参数列表,即参数的数量或参数类型不能完全相同
2、重写：是存在子父类之间的,子类定义的方法与父类中的方法具有相同的方法名字,相同的参数表和相同的返回类型
3、重写是父类与子类之间多态性的一种表现
4、重载是一类中多态性的一种表现
程序演示
重载
public class OverLoad {
public static void main(String[] args) {
int a=10;
int b=20;
String name="lisi";
f1();
f1(a);
f1(a,b);
f1(a,b,name);
}
private static void f1(int a, int b, String name) {
System.out.println(a+b+name);//30name
}
private static void f1() {
System.out.println("f1()");
}
private static void f1(int a) {
System.out.println(a);
}
private static void f1(int a, int b) {
System.out.println(a+b);
}
}重写
public class Override {
public static void main(String[] args) {
Sub3 s=new Sub3();
s.testShow();//调用普通方法，
s.eat();//调用重写方法，子类已经重写了父类的方法，从此再用，就是儿子的实现方式
}
}
class Fu3{
public void show(){
System.out.println("Fu...show()");
}
public void eat(){
System.out.println("爸爸吃肉");
}
}
class Sub3 extends Fu3{
//普通方法
public void testShow(){
super.show();//调用父类的eat()
}
//重写方法
//方法签名完全一致的情况就是发生了重写
public void eat(){
System.out.println("儿子吃肉");
}
}