在jvm内存中主要分布有以下三个区域：
栈：存放基础数据和自定义对象的引用
堆：主要存储创建的对象，即new出来的对象
方法区：加载存放class文件（字节码文件）
什么是封装？
封装是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
封装的优点：
隐藏代码的实现细节，提高安全性。
private 私有属性：（调用属性先执行提供的get或set方法）
私有属性：
class Person {
//姓名
private String name;
//年龄
private int age;
//对外提供公共的访问方式，编写set和get方法
public void setAge(int _age){
if(_age>0 && _age < 120){
age = _age;
}else{
System.out.println("年龄不符合常理，请重新设置！");
}
}
public int getAge(){
return age;
}
public void setName(String _name){
name = _name;
}
public String getName(){
return name;
}
}
基本数据类型的参数传递，值传递：（值不会受到影响）
/*
基本数据类型的参数传递，值传递
*/
public class ParamTest01{
public static void m1(int i){
i = i + 1;
System.out.println("m1方法中的i=" + i);//11
}
public static void main(String[] args){
int i = 10;
m1(i);
System.out.println("main方法中的i=" + i);//10
}
}
引用数据类型传递，传递的是引用传递（值会改变）
/*
引用数据类型的参数传递，传递的引用，引用传递
*/
public class AnimalTest01 {
public static void m1(Animal a){
int age = a.getAge();
a.setAge(++age);
System.out.println("m1方法中的age=" + a.getAge());//11
}
public static void main(String[] args) {
Animal a = new Animal();
a.setAge(10);
m1(a);
System.out.println("main方法中的age=" + a.getAge());//11
}
}
构造方法：
对象被创建时会执行
构造方法（constructor），有的地方叫做构造器或者构造函数。
构造方法的作用是给对象数据进行初始化。
构造方法格式特点
1.方法名与类名相同(注意大小写也要与类名一致)
2.没有返回值类型
3.没有void修饰
4.没有具体的返回值return;
5.如果一个类没有提供任何构造方法，系统默认提供无参数构造方法
6.如果一个类已经手动的提供了构造方法，那么系统不会再提供任何构造方法。
定义构造方法
class User{
private String name;
private int age;
//构造方法，最好手动编写一个无参的构造方法
public User(){
System.out.println("构造方法");
}
public User(String _name, int _age){
name = _name;
age = _age;
}
public String getName(){
return name;
}
public void setName(String _name){
name = _name;
}
public int getAge(){
return age;
}
public void setAge(int _age){
age = _age;
}
}
调用
public class UserTest01 {
public static void main(String[] args) {
User u = new User();
//u.User();不能手动调用构造方法
/*
User u = new User("赵六",20);
System.out.println(u.getName());
System.out.println(u.getAge());
*/
}
}
通过this 关键字（指代当前类） 实例对象调时 值显示对象传入的值 （注意：java中就存在近原则）
实例
static（修饰类的变量，和对象没有关系）
可以修饰变量，被static修饰的变量叫做静态变量，
程序运行时静态变量存放在方法区里面，因此，静态变量在类加载阶段赋值，并且只赋值一次。
class Employee{
private String name;
static String company = "阿里巴巴";
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public class StaticTest01 {
public static void main(String[] args){
Employee e = new Employee();
System.out.println(e.company);//开发中不建议这样使用
e = null;
System.out.println(e.company);//不报错，static修饰的变量跟对象没有关系
System.out.println(Employee.company);//开发中建议这样写，使用类名.静态变量名的方式访问静态变量
}
}
static可以修饰方法，被static修饰的方法叫做静态方法，（修饰方法，和对象没有关系）
不用创建对象就能能直接访问该方法，即使用类名.静态方法名的方式。
静态方法不能访问非静态的数据（调用非静态方法也不可以），静态方法不能使用this。
public class StaticTest02{
int i;
public void m1(){
System.out.println("m1方法");
}
public static void m2(){
//m1();//error静态方法不能引用非静态方法
//System.out.println(i);//error静态方法不能引用非静态变量
System.out.println("静态方法m2");
}
public static void main(String[] args){
StaticTest02 st = new StaticTest02();
st.m1();
m2();//静态方法可以直接调用静态方法
StaticTest02.m2();//开发中建议这样使用
st = null;
st.m2();//开发中不建议这样使用，静态方法跟对象无关
}
}
static可以定义静态语句块，静态语句块在类加载阶段执行，并且只执行一次，并且是自上而下的顺序执行，在构造方法之前执行。
public class StaticTest03{
//静态语句块中的内容只会执行一次
static{
System.out.println("静态语句块1");
}
static{
System.out.println("静态语句块2");
}
static{
System.out.println("静态语句块3");
}
public StaticTest03(){
System.out.println("构造方法");
}
public static void main(String[] args){
System.out.println("main方法1");
System.out.println("main方法2");
new StaticTest03();
new StaticTest03();
}
}
代码块
局部代码块，在方法中出现，限定变量生命周期，及早释放，提高内存利用率
构造代码块，在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
静态代码块， 在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。一般用于加载驱动。
同步代码块(后面多线程部分会讲解)
public class BlockTest01 {
public static void main(String[] args) {
//局部代码块
{
int x = 10;
System.out.println(x);
}
//System.out.println(x);
Student s1 = new Student();
System.out.println("------------");
Student s2 = new Student();
}
static{
System.out.println("BlockTest01中的静态代码块");
}
}
class Student {
public Student(){
System.out.println("构造方法");
}
//构造代码块
{
System.out.println("构造代码块");
}
static{
System.out.println("静态代码块");
}
先执行静态代码块 局部代码块 构造代码 构造方法
继承：extends
子类不能访问父类中private修饰的方法
public class Test01 {
public static void main(String[] args) {
SubClass s = new SubClass();
s.m1();
//s.m2();//error子类不能访问父类中private修饰的方法
s.m3();
s.m0();//子类可以访问到其祖先类的方法
}
}
重写，也叫做覆盖，当父类中的方法无法满足子类需求时，子类可以将父类的方法进行重写编写来满足需求。比如孩子继承了父亲的房子，可以将房子重新装修。
方法重写的条件：
- 两个类必须是继承关系
- 必须具有相同的方法名，相同的返回值类型，相同的参数列表.
- 重写的方法不能比被重写的方法拥有更低的访问权限。
- 重写的方法不能比被重写的方法抛出更宽泛的异常。
- 私有的方法不能被重写。
- 构造方法无法被重写，因为构造方法无法被继承。
- 静态的方法不存在重写。
- 重写指的是成员方法，和成员变量无关。
super 关键字 调用父类方法 或 变量
public class Dog extends Animal {
public String name = "旺财";
public void eat(){
System.out.println("吃狗粮");
}
public Dog(){
//super("土豪金","藏獒");super()
System.out.println("Dog中的无参构造方法");
}
public void m1(){
System.out.println(super.name);
System.out.println(this.name);//可以不加this
super.eat();
this.eat();//可以不加this
}
}
多态： 不同实例调用相同方法时返回值却不相同
public class AnimalTest01 {
public static void main(String[] args) {
Cat c1 = new Cat();
c1.eat();
Animal a1 = new Cat();//父类引用指向子类对象，自动类型转换，也叫做向上转型
a1.eat();//动态绑定和静态绑定
//System.out.println(a1.num);//结果10，说明成员变量不存在重写
//a1.move();
Cat c2 = (Cat)a1;//强制类型转换，也叫做向下转型
c2.move();
Animal a2 = new Dog();
if(a2 instanceof Cat){
Cat c4 = (Cat)a2;
}else{
System.out.println("a2不是Cat类型");
}
//Cat c3 = (Cat)a2;//error ClassCastException类转型错误
}
}
成员变量不存在重写
final：
final修饰的类无法被继承。
final修饰的方法无法被重写。
final修饰的局部变量，一旦赋值，不可再改变。
final修饰的成员变量必须初始化值。
public class FinalTest01{
public final int k = 10;
//常量，标识符大写
public static final double PI = 3.14;
public static void main(String[] args){
/*
final int i = 10;
i = 20;
*/
}
}
final修饰的基本数据类型，值不能改变
final修饰的引用数据类型，指向地址是不能改变的，但是对象里面的值是可以改变的
抽象类：abstract
public abstract class A{
public A(){
System.out.println("class A");
}
//抽象方法
public abstract void m1();
public static void main(String[] args){
//A a = new A();//抽象类不能被实例化
A a = new B();
a.m1();
}
}
class B extends A{
public void m1(){
System.out.println("class B中的m1方法");
}
public B(){
super();
System.out.println("class B");
}
}
原文地址：https://www.cnblogs.com/lizhioeng/p/9419864.html