JAVA语言的一些基础部分与C语言类似，故本文直接从面向对象开始说起：
首先需要了解几个概念：
对象：客观存在并且能够区分的个体，在JAVA中万事万物皆对象。
类：具有相同特征或者行为的对象的集合
类是对象的概括，对象是类的实例
类的声明：
class{ //成员变量； //成员方法; }
修饰符：
在一个类中应该有构造器：用于创建对象；
在构造器中应该注意：
①构造器名必须和类名一致。
②构造器没有返回值类型。
③任何类都含有构造器。
④如果没有显式地定义类的构造器，则系统会为该类提供一个默认的无参的构造器。一旦在类中显式地定义了构造器，系统就不会再为这个类提供默认的构造器了。如需要使用无参的构造器，需要自行在类中进行定义。
对象是类的实例：类名 对象名=new 类名();
final关键字：可以修饰：
基本数据类型：被final修饰的基本数据类型一旦被赋值后，其值不能被改变。
引用数据类型：被final修饰的引用数据类型，地址不能修改，但是对象本身的属性可以修改。
方法：被final修饰的方法是将方法锁定，继承类不能修改此方法。
类：被final修饰的类不能被任何类继承，会“断子绝孙”！
abstract关键字：可以修饰：
方法：被abstract修饰的方法就是没有被实现的方法，没有方法体,注意被abstract修饰的方法不能用private修饰，否则子类无法访问到该方法；
类：被abstract修饰的类为抽象类，此类的主要作用就是被继承，继承类必须实现抽象类中的所有抽象方法。
代码块：代码块是类的成分之一，在Java中，使用 { } 括起来的代码被称为代码块。
分类：
局部代码块：用于限定变量生命周期，及早释放，提高内存利用率。
局部代码块中声明的变量在代码块外部访问不到！
静态代码块：必须要被static修饰，主要用于对静态属性进行初始化。
必须放在类中， 随着类一起加载执行，且只执行一次。
实例（构造）代码块：调用构造方法都会执行，并且在构造方法前执行。
无static修饰。属于对象，与对象的创建一起执行的。
每次调用构造器初始化对象，实例代码块都要自动触发执行 一次。
实例代码块实际上是提取到每一个构造器中去执行的。
实例代码块中的内容在构造方法前执行。
同步代码块：一种多线程保护机制，在Java高级部分的多线程部分会详细说明。
Java面向对象的三大特性：封装、继承、多态
一、封装
所谓封装就是在定义一个类时，将类的成员变量进行私有化，用private修饰，私有属性只能在类的内部被访问，如果类外部想要访问类的私有属性时，需要提供一些public方法（setXX()和getXX()）。
方法的重载：方法重载就是在一个类中，有相同名称的函数，但函数的形参不同。
重载的规则：
1、在同一个类中；
2、方法名称必须相同；
3、方法的参数列表不相同；
4、方法重载与方法的返回值类型无关。
this关键字：this 关键字是 Java 常用的关键字，可用于任何实例方法内指向当前对象，也可指向对其调用当前方法的对象，或者在需要当前类型对象引用时使用。
this.属性名：调用对象的属性
this.方法名：调用对象的方法
题目概述：编写一个超市购物程序，如果购物者所要购买的程序超市中有，则提示购物者买到了某商品，否则提示购物者白跑一趟。
package primary; import java.util.Objects; public class Product { private String productName; public Product(String productName) { this.productName = productName; } public Product() { } public String getProductName() { return productName; } public void setProductName(String productName) { this.productName = productName; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Product product = (Product) o; return Objects.equals(productName, product.productName); } @Override public int hashCode() { return Objects.hash(productName); } } package primary; public class Market { private String marketName; private int count=0; private int kinds; public Product[] products; public Market(String marketName,int kinds) { products=new Product[kinds]; this.marketName = marketName; this.kinds=kinds; } public void putProduct(Product product) { if(product!=null&&count<kinds){ products[count++]=product; } } public Product getProduct(int i){ return products[i]; } public int getCount() { return count; } public void setCount(int count) { this.count = count; } public int getKinds() { return kinds; } public void setKinds(int kinds) { this.kinds = kinds; } public Market() { } public String getMarketName() { return marketName; } public void setMarketName(String marketName) { this.marketName=marketName; } } package primary; public class Person { private Product wantBuy; public Product getWantBuy() { return wantBuy; } public Person() { } public void setWantBuy(Product wantBuy) { this.wantBuy = wantBuy; } public Person(Product wantBuy) { this.wantBuy = wantBuy; } public void findthing(Product wantBuy,Market market){ boolean flag=false; for(int i=0;i<market.getCount();i++){ if(wantBuy.equals(market.getProduct(i))){ flag=true; break; } } if(flag){ System.out.println("在" + market.getMarketName() + "买到了" + wantBuy.getProductName() + "!"); }else{ System.out.println(market.getMarketName() + "没有" + wantBuy.getProductName() + ",白跑一趟！"); } } } package primary; import java.util.Scanner; public class Shopping { public static void main(String[] args) { Product p1=new Product("豆浆"); Product p2=new Product("西瓜"); Product p3=new Product("茉莉花茶"); Product p4=new Product("鸡蛋"); Product p5=new Product("青菜"); Product p6=new Product("牛奶"); Market m1=new Market("嘉润超市",10); Market m2=new Market("好又多超市",10); m1.putProduct(p1); m1.putProduct(p3); m1.putProduct(p6); m2.putProduct(p1); m2.putProduct(p2); m2.putProduct(p5); m2.putProduct(p4); System.out.println("请问您要去买什么："); Scanner sc1=new Scanner(System.in); Product wantBuy=new Product(sc1.nextLine()); System.out.println("请问您要去哪个超市买：（1.嘉润；2.好又多）"); Scanner sc2=new Scanner(System.in); int selection=sc2.nextInt(); Person person=new Person(); if(selection==1){ person.findthing(wantBuy,m1); }else if(selection==2){ person.findthing(wantBuy,m2); }else{ System.out.println("您的输入有误！"); } } }
运行结果 ：
请问您要去买什么：
豆浆
请问您要去哪个超市买：（1.嘉润；2.好又多）
1
在嘉润超市买到了豆浆!
成员内部类：在JAVA中允许在一个类内部定义一个类
在成员内部类中允许访问外部类的所有成员。
创建内部类对象的具体语法格式如下：
外部类名.内部类名 变量名=new 外部类名().new 内部类名();
注意：当内部类被声明私有，外界将无法访问
二、继承
在Java中，类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类。子类继承父类的属性和方法，使得子类对象（实例）具有父类的特征和行为。
继承应该注意的问题：
（1）在Java中，类只支持单继承，不允许多重继承。也就是说一个类只能有一个直接父类
（2）多个类可以继承一个类
（3）B类继承A类，C类继承B类，C类同样也继承了A类，A类也是C类的父类
（4）在Java中，子类和父类是一种相对概念，一个类可以是某个类的父类，也可以是另一个类的子类。
子类通过extends继承父类
方法的重写：在继承关系中，子类会自动继承父类中定义的方法，但有时在子类中需要对继承的方法进行一些修改，即对父类的方法进行重写。
但是在方法重写中应该注意：子类中重写后的方法应该和父类中的方法有相同的函数名、参数列表、返回值，但是子类不能比父类拥有更严格的访问权限。
方法重写和方法重载的区别：
方法重载：
1、同一个类中
2、方法名相同，参数列表不同（参数顺序、个数、类型）
3、方法返回值、访问修饰符任意
方法重写：
1、有继承关系的子类中
2、方法名相同，参数列表相同（参数顺序、个数、类型），方法返回值相同
3、子类的访问修饰符访问范围需要大于等于父类的访问范围
super关键字：子类可以通过super关键字调用父类的方法、属性、构造器。
注意：如果子类要调用父类的构造器时super（）只能出现在第一行，并且只能出现一次。
this关键字和super关键字不让同时出现，以为this关键字和super关键字都必须出现在构造方法的首行。
抽象类：被abstract修饰的类，含有抽象方法。
抽象类的定义规则如下：
（1）包含一个以上抽象方法的类必须是抽象类。
（2）抽象类和抽象方法都要使用abstract关键字声明。
（3）抽象方法只需声明而不需要实现。
（4）如果一个类继承了抽象类，那么该子类必须实现抽象类中的全部抽象方法。
接口：接口是一种特殊的类，由全局常量和公共的抽象方法组成，不能包含普通方法。
接口中常量前面的访问修饰符默认为public static final，并且在接口中方法的默认访问权限为public abstract。
子类通过implements来实现接口，子类可以实现多个接口，并且子类必须实现接口中的所有抽象方法。
抽象类和接口的区别：
（1）抽象类是一个类，允许含有构造方法和私有的成员变量，但接口中不允许；
（2）抽象类中可以含有普通方法，但是接口中只能有抽象方法；
（3）一个类只能继承一个抽象类，但可以实现多个接口。
（4）一个类继承抽象类时只需重写类中的抽象方法，而实现接口时必须重写其所有方法。
三、多态
在Java中，多态是指不同对象在调用同一个方法时表现出的多种不同行为。
在Java中，多态的两种主要形式：方法重载、方法重写
对象类型转换：
（1）向上转型：子类对象->父类对象
在向上转型中，系统会自动完成
（2）向下转型：父类对象->子类对象
在向下转型中首先应利用instanceOf进行一个判断，否则可能会出现异常
Person p=new Man(); if(p instanceOf Man){ Man p1=(Man) p; }
注意：Man类是Person类的一个子类！
instanceOf关键字：判断一个对象是否是某个类（或接口）的实例。
语句格式为：对象名 instanceOf 类名
