在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中就存在近原则）
实例
View Code
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"); } }