面向对象的主要特点：
封装性：属性和行为封装起来
继承性:
多态性：
1，创建对象： 类名 对象名称 = new 类名（）；
创建对象后，可以通过对对象的引用来访问对象所有的成员。对象的引用.对象成员。
package st.peter.obj; public class Student { String name; int age; public void say() { System.out.println("我叫"+name+"今年"+age+"岁"); } } package st.peter.obj; public class Demo1 { public static void main(String[] args) { Student stu = new Student(); stu.name = "peter"; stu.age = 15; stu.say(); } }所谓类的封装是指在定义一个类时，将类中的属性私有化，即使用private关键字来修饰，私有属性只能在他所在的类中被访问，为了能让外界访问私有属性，需要提供一些使用public修饰的公有方法，其中包括用于获取属性值的getXxx()方法和设置属性值的setXxx()方法。
2，构造方法
在实例化对象的同时就为这个对象的属性进行赋值，可以通过构造方法来实现。构造方法在类实例化对象时被自动调用。
构造方法的定义：
（1）方法名与类名相同
（2）方法名的前面没有返回值的类型的声明
（3）方法中不能使用return语句返回一个值
package st.peter.obj; public class Person { public Person() { System.out.println("这是一个无参的构造方法!"); } } package st.peter.obj; public class Demo2 { public static void main(String[] args) { Person p = new Person(); } }有参数的构造方法
package st.peter.obj; public class Person { int a; public Person(int age) { a = age; } public void say() { System.out.println("我今年"+a+"岁"); } } package st.peter.obj; public class Demo2 { public static void main(String[] args) { Person p = new Person(24); p.say(); } }3，构造方法的重载
与普通方法一样，构造方法也可以重载，在一个类中可以定义多个构造方法，只要每个构造方法的参数类型或参数个数不同即可。
package st.peter.obj; public class Person { int age; String name; //一个参数的构造方法 public Person(int age) { this.age = age; } //两个参数的构造方法 public Person(int age,String name) { this.age = age; this.name = name; } public void say() { System.out.println("我今年"+age+"岁"+"我叫"+name); } } package st.peter.obj; public class Demo2 { public static void main(String[] args) { Person p = new Person(24); Person p1 = new Person(23,"peter"); p.say(); p1.say(); } }在一个类中定义一个无参数的构造方法最好再定义一个有参数的构造方法。
构造方法通常使用public来修饰。
4，this关键字
（1）this关键字可以明确地去访问一个类的成员变量，解决与局部变量名称冲突的问题。
（2）this关键字可以调用成员方法
（3）在构造方法中使用this(参数1，参数2，...)的形式调用其他的构造方法。this()
在构造方法中使用this调用构造方法的语句必须位于第一行，且只能出现一次。
不能在一个类中的两个构造方法中使用this互相调用。
5，垃圾回收
Java引用垃圾回收机制，虚拟机会自动回收垃圾对象所占用的内存空间。
6，static关键字
（静态变量）：
静态变量被所有的实例共享，可以用类名.变量名的形式访问。只能修饰成员变量
package st.peter.obj1; public class School { static String schoolName; } package st.peter.obj1; public class Demo3 { public static void main(String[] args) { School s1 = new School(); School s2 = new School(); School.schoolName = "大连大学"; System.out.println(s1.schoolName); System.out.println(s2.schoolName); } }（静态方法）
在不创建对象的时候调用方法。
package st.peter.obj1; public class School { public static void say() { System.out.println("hello static method!"); } } package st.peter.obj1; public class Demo3 { public static void main(String[] args) { School.say(); } }
（静态代码块）
static{
}当类被加载时，静态代码块会被执行，由于类只加载一次，因此静态代码块只执行一次。
7，内部类：类的内部定义类
（成员内部类）
成员内部类可以访问外部类的所有成员。
package st.peter.obj1; public class Outer { private int num = 4; public void test() { Inner inner = new Inner(); inner.show(); } //定义一个成员内部类 class Inner{ public void show() { System.out.println(num); } } } package st.peter.obj1; public class Demo4 { public static void main(String[] args) { Outer outer = new Outer(); outer.test(); } }通过外部类来访问内部类
Outer.Inner inner = new Outer().new Inner(); inner.show();（静态内部类）
package st.peter.obj1; public class Outer { static private int num = 4; //定义一个静态内部类 static class Inner{ public void show() { System.out.println(num); } } } package st.peter.obj1; public class Demo4 { public static void main(String[] args) { //Outer outer = new Outer(); //outer.test(); Outer.Inner inner = new Outer.Inner(); inner.show(); } }（方法内部类）
package st.peter.obj1; public class Outer { static private int num = 4; public void func() { class Inner{ public void say() { System.out.println(num); } } Inner inner = new Inner(); inner.say(); } } package st.peter.obj1; public class Demo4 { public static void main(String[] args) { Outer outer = new Outer(); outer.func(); } }
