软件出现的目的：
*用计算机的语言来描述世界
*用计算机解决现实世界的问题
面向对象的思想 描述 面向对象的世界
面向对象设计和开发程序的好处：
*交流更加流畅
*提高设计和开发效率
构造方法：
构造方法是用来描述对象创建的过程，构造方法在对象创建的过程中被调用
语法：
访问修饰符 构造方法名(){
//初始化代码
}
注意：构造方法名必须和类名相同；没有返回值；
方法重载：
*方法名相同
*参数项不同
*与返回值和访问修饰符无关
this关键字用法：
调用属性：
this.属性名=100；
调用方法：
this.方法名();
调用构造方法：
this();
this(参数);
如何使用：必须是构造方法中的一条语句
面向对象的三大特征之一—封装
封装的概念：
封装：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息
的操作和访问；
封装的好处:
*隐藏类的实现细节
*只能通过规定方法访问数据
*方便加入控制语句
*方便修改实现
封装的步骤：
1.修改属性的可见性
2.创建getter和setter方法
3.在getter\setter方法中加入属性控制语句
static修饰符：
static的资源属于类级别的资源，静态资源，对于类的所有实例对象共享
static关键字可以用来修饰属性，方法，代码块和内部类
static修饰符的资源，在类加载期间执行
1、static修饰的属性：
static关键字修饰的属性，属于对类所有实例对象共享的变量
访问静态的属性：类名.属性名
2、static修饰方法：
static关键字修饰的方法，属于静态方法，可以直接类名.方法名()进行调用.一般
的是静态方法作为工具方法
静态方法中不能调用对象的资源（对象的属性和方法）
3、static修饰的代码块
在类加载的时候执行，因为类只加载一次，所以static的代码块也只运行一次，
一般是使用static代码块来加载一些静态资源，比如说配置文件；
{
这里就是代码块，和构造方法一样，在对象创建时候执行
}
static{
这里就是静态代码块
}
Static和非Static的区别
1.属性
2.方法
3.调用方法
4.归属
static全部属于类
非static属于实例和对象
继承：
一、继承的前提条件：
子类和父类之间，必须要满足子类is a父类的逻辑关系，才能继承
二、继承的优点
1.提高代码之间的重用性，（继承之后子类共用父类的代码）
2.提高了代码后期的可维护性（后期代码中需要添加或删除某些代码，只需修改父类代码即可）
三、继承的步骤：
1.将多个类中共有的属性和方法提取出来，建立一个父类
2.在子类后面使用extends关键字完成继承， 子类 extends 父类
3.在子类中可以调用父类的代码
注意：在java中属于单继承，在extends关键字后面只能有一个父类
子类访问父类成员：
访问父类构造方法：
super();
super(参数)；
访问父类属性：
super.属性名；
访问父类方法：
super.方法名();
注意：this和super都必须出现在第一行，他们之间是互斥的
子类不能继承父类的那些资源：
1.private成员
2.子类与父类不在同包，使用默认访问权限的成员
3.构造方法
访问修饰符：
1.private 私有的
2.默认的（friendly） 默认
3.protected 受保护的
4.public 公共的
多重继承关系的初始化顺序是怎样的：
1.父类属性
2.父类构造方法
3.子类属性
4.子类构造方法
对象初始化过程：
第一步：在创建类之前，检查类是否已加载（检查硬盘上的.class的文件是否加载到内存中）
如果没有加载就先加载父类的文件，再加载本类的文件
java使用的策略称为：懒惰式加载（按需加载）用到的时候加载，只加载一次。
第二部：分配对象空间，递归分配所有父类的属性空间，
属性会自动的初始化为"0"值；
第三步：属性赋值
第四步：调用父类的构造方法（默认调用父类的无参构造方法）
第五步：调用本类的构造方法
方法重写：
*方法名相同
*参数列表相同
*返回类型相同或是其子类
*子类访问权限大于或等于父类
super关键字访问父类的成员：
super只能出现在子类的方法和构造方法中
super调用构造方法时，只能是第一句
super不能访问父类的private成员
abstract关键字:
abstract是抽象的意思，可以修饰类和方法，修饰类我们称之为抽象类，修饰方法我们称之为抽象方法
1.abstract 修饰类，抽象类
public abstract class 类名(){}
抽象类用来表示一些抽象的概念
抽象类特点：
*抽象类不能被实例化
*抽象类可以有属性、方法、构造方法，都是用来给子类继承
*抽象类中不一定都是抽象方法。
2.abstract 修饰方法，抽象方法
访问修饰符 abstract 返回值类型 方法名(参数列表)；
抽象方法不需要自己实现，由子类来实现
抽象方法特点：
*抽象方法没有方法体
*抽象方法必须出现在抽象类中
*一个类继承抽象类之后必须要实现父类所有的抽象方法
3.抽象类可以继承抽象类
final关键字，表示最终的
1.final可以用来修饰类、方法和属性。
2.final修饰的类的不能再被继承。比如：String String是final修饰的类，不能被继承
3.final修饰的方法，不能再被子类重写
4.final修饰的变量初始化以后不能再发生改变
常量规范定义：public static final int ace=12;
final修饰的引用数据类型，引用地址不能发生改变，但是只限定第一层，引用类型的属性值是可以改变的
多态：
生活中：
同一种事物，由于条件不同，产生的结果不同。
程序中：
同一种引用类型，使用不同的实例而执行不同的操
实现多态的两个要素：
1.子类重写父类方法
2.使用父类的类型
子类到父类的转换（向上转型）：
Pet pet=new Dog();
实现多态的两种形式：
*使用父类作为方法形参实现多态
*使用父类作为方法返回值实现多态
父类到子类的转换（向下转型）
强制类型转换
前提是：已经向上转型
称为：还原行为
语法：
子类名 子类自命名=（子类名） 父类名；
Dog dog = (Dog) pet;
instanceof运算符：
判断对象是否是属于类和接口，返回boolean类型
对象 instanceof 类或接口软件出现的目的：
*用计算机的语言来描述世界
*用计算机解决现实世界的问题
面向对象的思想 描述 面向对象的世界
面向对象设计和开发程序的好处：
*交流更加流畅
*提高射击和开发效率
构造方法：
构造方法是用来描述对象创建的过程，构造方法在对象创建的过程中被调用
语法：
访问修饰符 构造方法名(){
//初始化代码
}
注意：构造方法名必须和类名相同；没有返回值；
方法重载：
*方法名相同
*参数项不同
*与返回值和访问修饰符无关
this关键字用法：
调用属性：
this.属性名=100；
调用方法：
this.方法名();
调用构造方法：
this();
this(参数);
如何使用：必须是构造方法中的一条语句
面向对象的三大特征之一—封装
封装的概念：
封装：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息
的操作和访问；
封装的好处:
*隐藏类的实现细节
*只能通过规定方法访问数据
*方便加入控制语句
*方便修改实现
封装的步骤：
1.修改属性的可见性
2.创建getter和setter方法
3.在getter\setter方法中加入属性控制语句
static修饰符：
static的资源属于类级别的资源，静态资源，对于类的所有实例对象共享
static关键字可以用来修饰属性，方法，代码块和内部类
static修饰符的资源，在类加载期间执行
1、static修饰的属性：
static关键字修饰的属性，属于对类所有实例对象共享的变量
访问静态的属性：类名.属性名
2、static修饰方法：
static关键字修饰的方法，属于静态方法，可以直接类名.方法名()进行调用.一般
的是静态方法作为工具方法
静态方法中不能调用对象的资源（对象的属性和方法）
3、static修饰的代码块
在类加载的时候执行，因为类只加载一次，所以static的代码块也只运行一次，
一般是使用static代码块来加载一些静态资源，比如说配置文件；
{
这里就是代码块，和构造方法一样，在对象创建时候执行
}
static{
这里就是静态代码块
}
Static和非Static的区别
1.属性
2.方法
3.调用方法
4.归属
static全部属于类
非static属于实例和对象
继承：
一、继承的前提条件：
子类和父类之间，必须要满足子类is a父类的逻辑关系，才能继承
二、继承的优点
1.提高代码之间的重用性，（继承之后子类共用父类的代码）
2.提高了代码后期的可维护性（后期代码中需要添加或删除某些代码，只需修改父类代码即可）
三、继承的步骤：
1.将多个类中共有的属性和方法提取出来，建立一个父类
2.在子类后面使用extends关键字完成继承， 子类 extends 父类
3.在子类中可以调用父类的代码
注意：在java中属于单继承，在extends关键字后面只能有一个父类
子类访问父类成员：
访问父类构造方法：
super();
super(参数)；
访问父类属性：
super.属性名；
访问父类方法：
super.方法名();
注意：this和super都必须出现在第一行，他们之间是互斥的
子类不能继承父类的那些资源：
1.private成员
2.子类与父类不在同包，使用默认访问权限的成员
3.构造方法
访问修饰符：
1.private 私有的
2.默认的（friendly） 默认
3.protected 受保护的
4.public 公共的
多重继承关系的初始化顺序是怎样的：
1.父类属性
2.父类构造方法
3.子类属性
4.子类构造方法
对象初始化过程：
第一步：在创建类之前，检查类是否已加载（检查硬盘上的.class的文件是否加载到内存中）
如果没有加载就先加载父类的文件，再加载本类的文件
java使用的策略称为：懒惰式加载（按需加载）用到的时候加载，只加载一次。
第二部：分配对象空间，递归分配所有父类的属性空间，
属性会自动的初始化为"0"值；
第三步：属性赋值
第四步：调用父类的构造方法（默认调用父类的无参构造方法）
第五步：调用本类的构造方法
方法重写：
*方法名相同
*参数列表相同
*返回类型相同或是其子类
*子类访问权限大于或等于父类
super关键字访问父类的成员：
super只能出现在子类的方法和构造方法中
super调用构造方法时，只能是第一句
super不能访问父类的private成员
abstract关键字:
abstract是抽象的意思，可以修饰类和方法，修饰类我们称之为抽象类，修饰方法我们称之为抽象方法
1.abstract 修饰类，抽象类
public abstract class 类名(){}
抽象类用来表示一些抽象的概念
抽象类特点：
*抽象类不能被实例化
*抽象类可以有属性、方法、构造方法，都是用来给子类继承
*抽象类中不一定都是抽象方法。
2.abstract 修饰方法，抽象方法
访问修饰符 abstract 返回值类型 方法名(参数列表)；
抽象方法不需要自己实现，由子类来实现
抽象方法特点：
*抽象方法没有方法体
*抽象方法必须出现在抽象类中
*一个类继承抽象类之后必须要实现父类所有的抽象方法
3.抽象类可以继承抽象类
final关键字，表示最终的
1.final可以用来修饰类、方法和属性。
2.final修饰的类的不能再被继承。比如：String String是final修饰的类，不能被继承
3.final修饰的方法，不能再被子类重写
4.final修饰的变量初始化以后不能再发生改变
常量规范定义：public static final int ace=12;
final修饰的引用数据类型，引用地址不能发生改变，但是只限定第一层，引用类型的属性值是可以改变的
多态：
生活中：
同一种事物，由于条件不同，产生的结果不同。
程序中：
同一种引用类型，使用不同的实例而执行不同的操
实现多态的两个要素：
1.子类重写父类方法
2.使用父类的类型
子类到父类的转换（向上转型）：
Pet pet=new Dog();
实现多态的两种形式：
*使用父类作为方法形参实现多态
*使用父类作为方法返回值实现多态
父类到子类的转换（向下转型）
强制类型转换
前提是：已经向上转型
称为：还原行为
语法：
子类名 子类自命名=（子类名） 父类名；
Dog dog = (Dog) pet;
instanceof运算符：
判断对象是否是属于类和接口，返回boolean类型
对象 instanceof 类或接口
软件出现的目的：*用计算机的语言来描述世界*用计算机解决现实世界的问题
面向对象的思想 描述 面向对象的世界
面向对象设计和开发程序的好处：*交流更加流畅*提高射击和开发效率
构造方法：构造方法是用来描述对象创建的过程，构造方法在对象创建的过程中被调用
语法： 访问修饰符 构造方法名(){ //初始化代码}注意：构造方法名必须和类名相同；没有返回值；
方法重载：*方法名相同*参数项不同*与返回值和访问修饰符无关
this关键字用法：
调用属性：this.属性名=100；
调用方法： this.方法名();
调用构造方法：this();this(参数);如何使用：必须是构造方法中的一条语句
面向对象的三大特征之一—封装 封装的概念： 封装：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问；
封装的好处: *隐藏类的实现细节 *只能通过规定方法访问数据 *方便加入控制语句 *方便修改实现
封装的步骤： 1.修改属性的可见性 2.创建getter和setter方法 3.在getter\setter方法中加入属性控制语句
static修饰符：static的资源属于类级别的资源，静态资源，对于类的所有实例对象共享static关键字可以用来修饰属性，方法，代码块和内部类static修饰符的资源，在类加载期间执行
1、static修饰的属性： static关键字修饰的属性，属于对类所有实例对象共享的变量访问静态的属性：类名.属性名
2、static修饰方法：static关键字修饰的方法，属于静态方法，可以直接类名.方法名()进行调用.一般的是静态方法作为工具方法静态方法中不能调用对象的资源（对象的属性和方法）
3、static修饰的代码块在类加载的时候执行，因为类只加载一次，所以static的代码块也只运行一次，一般是使用static代码块来加载一些静态资源，比如说配置文件；{这里就是代码块，和构造方法一样，在对象创建时候执行} static{这里就是静态代码块}
Static和非Static的区别1.属性2.方法3.调用方法4.归属static全部属于类非static属于实例和对象
继承：一、继承的前提条件：子类和父类之间，必须要满足子类is a父类的逻辑关系，才能继承
二、继承的优点1.提高代码之间的重用性，（继承之后子类共用父类的代码） 2.提高了代码后期的可维护性（后期代码中需要添加或删除某些代码，只需修改父类代码即可）
三、继承的步骤：1.将多个类中共有的属性和方法提取出来，建立一个父类2.在子类后面使用extends关键字完成继承， 子类 extends 父类3.在子类中可以调用父类的代码注意：在java中属于单继承，在extends关键字后面只能有一个父类
子类访问父类成员：
访问父类构造方法：super();super(参数)；
访问父类属性：super.属性名；
访问父类方法：super.方法名();
注意：this和super都必须出现在第一行，他们之间是互斥的
子类不能继承父类的那些资源：1.private成员2.子类与父类不在同包，使用默认访问权限的成员3.构造方法
访问修饰符：1.private 私有的2.默认的（friendly） 默认3.protected 受保护的4.public 公共的
多重继承关系的初始化顺序是怎样的：1.父类属性2.父类构造方法3.子类属性4.子类构造方法
对象初始化过程：第一步：在创建类之前，检查类是否已加载（检查硬盘上的.class的文件是否加载到内存中）如果没有加载就先加载父类的文件，再加载本类的文件java使用的策略称为：懒惰式加载（按需加载）用到的时候加载，只加载一次。第二部：分配对象空间，递归分配所有父类的属性空间，属性会自动的初始化为"0"值；第三步：属性赋值第四步：调用父类的构造方法（默认调用父类的无参构造方法）第五步：调用本类的构造方法
方法重写：*方法名相同*参数列表相同*返回类型相同或是其子类*子类访问权限大于或等于父类
super关键字访问父类的成员：super只能出现在子类的方法和构造方法中super调用构造方法时，只能是第一句super不能访问父类的private成员
abstract关键字:abstract是抽象的意思，可以修饰类和方法，修饰类我们称之为抽象类，修饰方法我们称之为抽象方法1.abstract 修饰类，抽象类 public abstract class 类名(){} 抽象类用来表示一些抽象的概念
抽象类特点： *抽象类不能被实例化 *抽象类可以有属性、方法、构造方法，都是用来给子类继承 *抽象类中不一定都是抽象方法。
2.abstract 修饰方法，抽象方法 访问修饰符 abstract 返回值类型 方法名(参数列表)； 抽象方法不需要自己实现，由子类来实现 抽象方法特点： *抽象方法没有方法体 *抽象方法必须出现在抽象类中 *一个类继承抽象类之后必须要实现父类所有的抽象方法
3.抽象类可以继承抽象类
final关键字，表示最终的1.final可以用来修饰类、方法和属性。2.final修饰的类的不能再被继承。比如：String String是final修饰的类，不能被继承
3.final修饰的方法，不能再被子类重写
4.final修饰的变量初始化以后不能再发生改变常量规范定义：public static final int ace=12;final修饰的引用数据类型，引用地址不能发生改变，但是只限定第一层，引用类型的属性值是可以改变的
多态：生活中：同一种事物，由于条件不同，产生的结果不同。
程序中：同一种引用类型，使用不同的实例而执行不同的操
实现多态的两个要素：1.子类重写父类方法2.使用父类的类型
子类到父类的转换（向上转型）：Pet pet=new Dog();
实现多态的两种形式：*使用父类作为方法形参实现多态*使用父类作为方法返回值实现多态
父类到子类的转换（向下转型）强制类型转换前提是：已经向上转型称为：还原行为语法：子类名 子类自命名=（子类名） 父类名；Dog dog = (Dog) pet;
instanceof运算符：判断对象是否是属于类和接口，返回boolean类型对象 instanceof 类或接口