定义类：
访问修饰符 class 类名{ }
访问修饰符如：public 、priate是可选的
class是声明类的关键字
按照命名规范，类名首字母大写
例：创建“人”类，关键代码：
public class Person{ }
**********************************************************
定义属性：
访问修饰符 数据类型 属性名；
访问修饰符士可选的
除了访问修饰符之外，其他的语法和声明变量是一致的
例：创建“人”类，名为“人”类添加相应属性，关键代码：
public class Person{
public String name;
public String gender;
public int age;
}
**********************************************************
定义方法：
访问修饰符 返回类型 方法名称（参数类型 参数名1，参数类型 参数名2，……）{ }
访问修饰符是可选的
返回类型可以是void，在定义方法时，返回类型为void时，表明没有返回值，方法体中不必使用“return”关键字返回具体数据，但是可以使用“return”关键字退出方法
返回类型不为“void”，那么在方法体中一定要使用“return”关键字返回对应类型的结果，否则程序会有编译错误
小括号中的“参数类型 参数名1，参数类型 参数名2，……”称为参数列表
当需要在方法执行的时候为方法传递参数时才需要参数列表，如果不需要传递参数时就可以省略，不过小括号不可以省略，传递多个参数时，以半角的括号进行分隔
例：在“人”类中定义方法，描述人工作的行为，关键代码：
public class Person{
public String name;
public String gender;
public int age;
public void work( ){
System.out.println(this.name+"的工作理念：为梦想而努力奋斗);
}
}
**********************************************************
创建和使用对象：
1、创建对象
类名 对象名 = new 类名（）；
new 是关键字
左边的类名为对象的数据类型
右边的类名（）称为类的构造方法
例：创建Person类的对象，关键代码：
Person lilei = new Person( );
2、使用对象
对象名 . 属性 //引用对象的属性
对象名 . 方法名 //引用对象的方法
例：对象属性赋值并调用方法
public static void main(String[] args){
Person lilei = new Person( );
lilei.name = "李雷"；
lilei.gender = "男"；
lilei.age = 22;
lilei.work( );
}
**********************************************************
成员方法：
1、带参数的方法
创建work（）方法时定义的参数叫做形式参数，简称形参。调用方法时传入的参数叫做实际参数，简称实参。
2、方法重载：
方法名相同，参数列表不同，就形成了方法重载
特点：在同一个类中，方法名相同，参数的个数或类型不同
**********************************************************
成员变量：
1、成员变量：类中的属性，直接在类中定义的变量，定义在方法的外部。PS：成员变量可以在声明时赋初始值，如果没有赋值，java会给它一个默认值，基本数据类型的值为0，引用类型的值为null
2、局部变量：定义在方法中的变量，一般情况下，在使用前需要赋值，否则会编译出错
**********************************************************
构造方法：
主要作用是进行一些数据的初始化
访问修饰符 方法名（参数列表）{方法体}
构造方法没有返回值
默认构造方法没有参数，因此参数列表可选（默认构造无参方法的快捷键：Alt+/）
构造方法的方法名与类名相同
如果写了带参的构造方法，必须要生成一个无参的构造方法
例：为Person类定义一个构造方法，关键代码：
public class Person{
public Person(){
this.name = "李雷";
}
}
在一个类中可以定义多个重载的构造方法
this关键字是对一个对象的默认引用，每个实例方法内部，都有一个this引用变量，指向调用这个方法的对象
因为this是在对象内部指代自身的引用，所以this只能调用实例变量、实例方法和构造方法。this不能调用类变量和类方法，this也不能调用局部变量。
1）使用this调用成员变量，解决成员变量和局部变量的同名冲突。
2）使用this调用成员方法
3）使用this调用重载的构造方法，只能在构造方法中使用，且必须是构造方法第一条语句
例：
public Penguin(String name,String sex){
this.name = name;
this.sex = sex;
}
public Penguin(String name, int health, int love, String sex){
this(name,sex);
this.health = health;
this.love = love;
}
**********************************************************
封装的步骤：
封装：
用OOP方式完成变量的声明、赋值、使用
完成2次（声明、赋值、使用）：1、封装的类 声明 赋值 使用 2、封装类里面属性的声明 赋值 使用
1、修改属性的可见性
将Person类中的属性由public修改为private即可。
例：请将Person类的属性私有化，关键代码：
public class Person{
private String name;
private String gender;
private int age;
}
2、设置setter/getter（）方法
例：请为Person类中的私有属性添加setter/getter（）方法，关键代码：
public class PrivatePerson{
private String name;
private String gender;
private int age;
public String getName(){
return name;
}
public void setName(String name){
this.name = name;
}
public String getGender(){
return gender;
}
public void setGender(String gender){
this.gender = gender;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age = age;
}
}
3、设置属性的存取限制
此时，属性仍然没有限制作用，需要进一步利用条件判断语句进行限制
例见myeclipse -->practise-->SetPerson
**********************************************************
定义包：
package 包名
package是关键字
报的声明必须是java源文件中的第一条非注释性语句，而且一个源文件只能有一个包声明语句，设计的包需要与文件系统结构相对应。因此，在命名包时，要遵守以下编码规范：
a、一个唯一的包名前缀通常是全部小写的ASCII字母，并且是一个顶级域名com、edu、gov、net、及org，通常使用组织的网络域名的逆序。例如，如果域名为javagroup.net，可以声明包名为“pacage net.javagroup.mypackage"
b、包名的后续部分依不同机构各自内部的规范不同而不同。这类命名规范可能以特定目录名的组成来区分部门、项目、机器或注册名，如“package net.javagroup.research.powerproject"
**********************************************************
包的使用：
包从大到小写：网址倒过来
1、声明包的含义是声明当前类所处的位置
2、导入包的含义是声明在当前类中要使用到的其他类所处的位置
//讲Person类放入pack1包中
package cn.bdqn.pack1;
public class Person{
……省略代码
}
//将PersonTest类放入pack2包中
//使用Person类时，需要使用import将其导入
package cn.bdqn.pack2;
import cn.bdqn.pack1.Person;
public class PersonTest{
public static void main(String[] atgs){
……省略代码
}
}
**********************************************************
类成员的访问修饰符：
作用域： 同一个类中 同一个包中 子类 任何地方
private 可以 不可以 不可以 不可以
默认修饰符 可以 可以 不可以 不可以
protected 可以 可以 可以 不可以
public 可以 可以 可以 可以
**********************************************************
static关键字的修饰属性：
static修饰的属性称为静态变量或者类变量，没有使用static修饰的属性称为实例变量。
例：将Person类的name、gender和age属性保留，新建一个static修饰的属性，并调用 ，关键代码：
public Person{
public String name;
public String gender;
public static int age;
public static int PERSON_LIVE;
//……省略代码
}
//以上为Person类代码，以下为调用代码
//……省略代码
Person hanbing = new Person();
hanbing.name = "韩冰";
hanbing.gender = "女";
hanbing.age = 22;
Person.PERSON_LIVE = 1;
实际开发中，static关键字修饰属性的最常用场景就是定义使用final关键字修饰的常量。使用final关键字修饰常量在整个程序运行时都不能被改变，和具体的对象没有关系，因此使用static修饰，
如“static final int PERSON_LIVE=1"
PS: 1、常量名一般由大写字母组成
2、声明常量时一定要赋初值
**********************************************************
static关键字的修饰方法：
static修饰的方法称为静态方法或者类方法，不用static关键字修改的方法称为实例方法。
例：将Person中的showDetails（）方法使用static关键字修饰，并调用 ，关键代码：
public Person{
public String name;
public String gender;
public static int age;
public static void showDetails(String name,String gender,int age){
System.out.println("姓名是："+name+"，性别为："+gender+"，年龄是："+age)；
}
}
//以上为Person类代码，以下为调用代码
public class PersonTest{
public static void main(String[] args){
Person liudun = new Person();
Person.showDetails("刘顿"，"男"，23);
}
}
1、在静态方法中不能直接访问实例变量和实例方法。
2、在实例方法中可以直接调用类中定义的静态变量和静态方法
**********************************************************
4种基本行为：
1）访问修饰符：公共的 私有的 受保护的 默认的
2）返回类型：
有：变量的定义 数据类型 变量名
没有：void
3）方法名：和类名的规范类似
a、方法名首字母小写
b、方法名由多个单词组成，从第二个单词开始，首字母大写
c、方法名要有意义
4）参数：
有：变量的声明部分（boolean flag）
没有：（）
5）方法体：作用域{ }
a、并列：多个方法可以并列
b、嵌套：方法不能嵌套；可以嵌套流程控制 {if ( ) { }}
第一种基本行为：访问修饰符 没有返回类型 方法名（没有）{ }
例：public void add( ){ }
第二种基本行为：访问修饰符 没有返回类型 方法名（有）{ }
例：public void add (int num1,int num2){ }
1、变量声明的过程：形参 形式上的参数
2、变量赋值的过程：实参 实际上的参数
第三种基本行为：访问修饰符 有返回类型 方法名（没有）{ }
例：public int add( ){ }
1、关键字：return 后面写的是变量名，返回类型位置写的是变量的数据类型
2、return后面不能再写代码了
第四种基本行为：访问修饰符 有返回类型 方法名（有）{ }
把第二种和第三种合在一起
例：public int add(int num1,int num2){ }
**********************************************************
继承的语法：
访问修饰符 class <SubClass> extends <SuperClass>{ }
在java中，继承通过extends关键字实现，其中SubClass称为子类，SuperClass称为父类或基类。
访问修饰符如果是public，那么该类在整个项目可见。
不写访问修饰符，则该类只在当前包可见。
在java中，子类可以从父类中继承以下内容：
可以继承public和protected修饰的属性和方法，不论子类和父类是否在同一个包里
可以继承默认访问修饰符修饰的属性和方法，但是子类和父类必须在同一个包里
无法继承父类的构造方法
**********************************************************
super使用的语法：
访问父类构造方法：super（参数）
访问父类属性/方法：super.<父类属性/方法>
super只能出现在子类（子类的方法和构造方法）中，而不是其他位置
super用于访问父类的成员，如父类的属性、方法、构造方法。
具有访问权限的限制，如无法通过super访问private
**********************************************************
实例化子类对象：
在java中，一个类的构造方法在如下两种情况中总是会执行：
1、创建该类的对象（实例化）
2、创建该类的子类的对象（子类的实例化）
因此，子类在实例化时，会首先执行其父类的构造方法，然后才执行子类的构造方法。
子类继承父类时构造方法的调用规则如下：
1、如果子类的构造方法中没有通过super显示调用父类的有参构造方法，也没有通过this显示调用自身的其他构造方法，则系统会默认先调用父类的无参构造方法。在这种情况下，是否写super（）语句，效果是一样的。
2、如果子类的构造方法中通过super显示调用父类的有参构造方法，那么将执行父类相应的构造方法，而不执行父类无参构造方法。
3、如果子类的构造方法中通过this显示调用自身的其他构造方法，在相应构造方法中应用以上两条规则
如果存在多级继承关系，在创建一个子类对象时，以上规则会多次向更高一级父类应用，一直到执行顶级父类Object类的无参构造方法为止。
**********************************************************
Object类：
Object类是所有类的父类。在java中，所有java类都直接或间接的继承了java.lang.Object类
关键代码：
public class Person{
}
//两种写法等价
public class Person extends Object{
}
**********************************************************
Object类的部分方法
方法 说明
toString（） 返回当前对象本身的有关信息，按字符串对象返回
equals（） 比较两个对象是否是同一个对象，若是，返回true
clone（） 生成当前对象的一个副本，并返回
hashCode（） 返回该对象的哈希代码值
getClass（） 获取当前对象所属的类信息，返回Class对象
**********************************************************
方法重写和方法重载的区别：
比较项 位置 方法名 参数表 返回值 访问修饰符
方法重写 子类 相同 相同 相同或是其子类 不能比父类更严格
方法重载 同类 相同 不相同 无关 无关
**********************************************************
多态：
例：宠物类Pet，有几个子类，宠物类定义了看病的方法toHospital()，子类分别重写看病方法，关键代码：
class Pet{
public void toHospital(){
system.out.println(“宠物看病！”)
}
}
class Dog extends Pet{
public void toHostipal(){
system.out.println(“小鸟看病”)
}
}
public class Test{
public static void main(String[] args){
Pet pet;
pet = new Dog();
pet.toHospital();
pet = new Bird();
pet.toHospital();
}
}
示例中，Pet类一般声明为抽象方法，因为其本身实例化没有任何意义，toHopital（）方法声明为抽象类。
抽象类不能被实例化
子类如果不是抽象类，则必须重写抽象类中的全部抽象方法
abstract修饰符不能和final修饰符一起使用
abstract修饰的抽象方法没有方法体
private关键字不能修饰抽象方法
**********************************************************
抽象方法：
抽象方法没有方法体
抽象方法必须在抽象类里
抽象方法必须在子类中被实现，除非子类是抽象类
**********************************************************
向上转型的语法：
子类到父类的转换称为向上转型
<父类型><引用变量名> = new <子类型>（）；
将一个父类的引用指向一个子类对象，称为向上转型，自动进行类型转换
此时通过父类引用变量调用的方法时子类覆盖或继承父类的方法，不是父类的方法
此时通过父类引用变量无法调用子类特有的方法
**********************************************************
向下转型的语法：
<子类型><引用变量名> = （<子类型>）<父类型的引用变量>
**********************************************************
instanceof运算符：
用于判断一个对象是否属于一个类
在向下转型的过程中，如果没有转换为真实子类类型，会出现类型转换异常
例：判断宠物类型，关键代码：
public class Test{
public static void main(String[] args){
Pet pet = new Bird();
pet.toHospital();
if(pet instanceof Dog){
Dog dog = (Dog) pet;
dog.catchingFlyDisc();
}else if(pet instanceof Bird){
Bird biird = (Bird) pet;
bird.fly();
}
}
}
使用instanceof时，对象的类型必须和instanceof后面的参数所指定的类在继承上有上下级关系，否则会出现编译错误。
**********************************************************
多态的应用：
1、使用父类作为方法的形参
例：一个主人类，在该类中定义控制动物叫的方法。 关键代码：
class Host{
public void letCry(Animal animal){
animal.cry();
}
}
public class Test{
public static void main (String[] args){
Host host = new Host;
Animal animal;
animal = new Dog();
host.letCry(animal);
animal = new Cat();
host.letCry(animal);
animal = new Duck();
host.letCry(animal);
}
}
2、使用父类作为方法的返回值
使用父类作为方法的返回值，也是Java中实现和使用多态的主要方式
例：主人送出三种动物，送出的动物可以叫。 关键代码：
class Host{
public Animal donateAnimal(String type){
Animal animal;
if(type=="dog"){
animal = new Dog();
}else if(type=="cat"){
animal = new Cat();
}else{
animal = new Duck();
}
return animal;
}
}
public class Test{
public static void main(String[] args){
Host host = new Host;
Animal animal;
animal = host.donateAnimal("dog");
animal.cry();
animal = host.donateAnimal("cat");
animal.cry();
}
}