java面向对象，final，super ，抽象类，重写，代码块，static，this，构造方法，堆栈

在jvm内存中主要分布有以下三个区域：

栈：存放基础数据和自定义对象的引用

堆：主要存储创建的对象，即new出来的对象

方法区：加载存放class文件（字节码文件）

什么是封装？
封装是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
封装的优点：
隐藏代码的实现细节，提高安全性。

private 私有属性：（调用属性先执行提供的get或set方法）

私有属性：

1class Person {
2    
3    //姓名
4    private String name;
5
6    //年龄
7    private int age;
8
9    //对外提供公共的访问方式，编写set和get方法
10    public void setAge(int _age){
11        if(_age>0 && _age < 120){
12            age = _age;
13        }else{
14            System.out.println("年龄不符合常理，请重新设置！");
15        }
16        
17    }
18    public int getAge(){
19
20        return age;
21    }
22
23
24    public void setName(String _name){
25        name = _name;
26    }
27    public String getName(){
28        
29        return name;
30    }
31}

View Code

**基本数据类型的参数传递，值传递：（值不会受到影响）
**

1/*
2    基本数据类型的参数传递，值传递
3*/
4public class ParamTest01{
5    
6    public static void m1(int i){
7        
8        i = i + 1;
9        System.out.println("m1方法中的i=" + i);//11
10        
11    }
12
13    public static void main(String[] args){
14    
15        int i = 10;
16        m1(i);
17        System.out.println("main方法中的i=" + i);//10
18    }
19}

引用数据类型传递，传递的是引用传递（值会改变）

1/*
2    引用数据类型的参数传递，传递的引用，引用传递
3*/
4public class AnimalTest01 {
5
6    public static void m1(Animal a){
7        int age = a.getAge();
8        a.setAge(++age);
9        System.out.println("m1方法中的age=" + a.getAge());//11
10
11    }
12
13    public static void main(String[] args) {
14        
15        Animal a = new Animal();
16        a.setAge(10);
17        m1(a);
18        System.out.println("main方法中的age=" + a.getAge());//11
19
20    }
21}

构造方法：

对象被创建时会执行

构造方法（constructor），有的地方叫做构造器或者构造函数。
构造方法的作用是给对象数据进行初始化。

构造方法格式特点
1.方法名与类名相同(注意大小写也要与类名一致)
2.没有返回值类型
3.没有void修饰
4.没有具体的返回值return;
5.如果一个类没有提供任何构造方法，系统默认提供无参数构造方法
6.如果一个类已经手动的提供了构造方法，那么系统不会再提供任何构造方法。

定义构造方法

1class User{
2    
3    private String name;
4    private int age;
5    
6    //构造方法，最好手动编写一个无参的构造方法
7    public User(){
8        
9        System.out.println("构造方法");
10    }
11
12    public User(String _name, int _age){
13        name = _name;
14        age = _age;
15    }
16
17    public String getName(){
18        return name;
19    }
20    public void setName(String _name){
21        name = _name;
22    }
23
24    public int getAge(){
25        return age;
26    }
27    public void setAge(int _age){
28        age = _age;
29    }
30}

View Code

调用

1public class UserTest01 {
2    public static void main(String[] args) {
3        
4        User u = new User();
5        //u.User();不能手动调用构造方法
6        /*
7        User u = new User("赵六",20);
8        System.out.println(u.getName());
9        System.out.println(u.getAge());
10        */
11    }
12}

View Code

通过this  关键字（指代当前类）      实例对象调时  值显示对象传入的值 （注意：java中就存在近原则）

实例 View Code

static（修饰类的变量，和对象没有关系）

可以修饰变量，被static修饰的变量叫做静态变量，
程序运行时静态变量存放在方法区里面，因此，静态变量在类加载阶段赋值，并且只赋值一次。

1class Employee{
2
3    private String name;
4    
5    static String company = "阿里巴巴";
6
7    public String getName() {
8        return name;
9    }
10
11    public void setName(String name) {
12        this.name = name;
13    }
14}
15
16
17public class StaticTest01 {
18
19    public static void main(String[] args){
20        Employee e = new Employee();
21        System.out.println(e.company);//开发中不建议这样使用
22        e = null;
23        System.out.println(e.company);//不报错，static修饰的变量跟对象没有关系
24        System.out.println(Employee.company);//开发中建议这样写，使用类名.静态变量名的方式访问静态变量
25        
26    }
27
28}

View Code

static可以修饰方法，被static修饰的方法叫做静态方法，（修饰方法，和对象没有关系）
不用创建对象就能能直接访问该方法，即使用类名.静态方法名的方式。
静态方法不能访问非静态的数据（调用非静态方法也不可以），静态方法不能使用this。

1public class StaticTest02{
2    
3    int i;
4
5    public void m1(){
6        System.out.println("m1方法");
7    }
8    
9    public static void m2(){
10        //m1();//error静态方法不能引用非静态方法
11        //System.out.println(i);//error静态方法不能引用非静态变量
12        System.out.println("静态方法m2");
13    }
14
15    public static void main(String[] args){
16        
17        StaticTest02 st = new StaticTest02();
18        st.m1();
19        m2();//静态方法可以直接调用静态方法
20        StaticTest02.m2();//开发中建议这样使用
21        st = null;
22        st.m2();//开发中不建议这样使用，静态方法跟对象无关
23    }
24
25}

View Code

static可以定义静态语句块，静态语句块在类加载阶段执行，并且只执行一次，并且是自上而下的顺序执行，在构造方法之前执行。

1public class StaticTest03{
2    //静态语句块中的内容只会执行一次
3    static{
4        System.out.println("静态语句块1");
5    }
6
7    static{
8        System.out.println("静态语句块2");
9    }
10    
11    static{
12        System.out.println("静态语句块3");
13    }
14    public StaticTest03(){
15    
16        System.out.println("构造方法");
17    }
18    public static void main(String[] args){
19        
20        System.out.println("main方法1");
21        System.out.println("main方法2");
22        new StaticTest03();
23        new StaticTest03();
24    }
25
26}

View Code

代码块

局部代码块，在方法中出现，限定变量生命周期，及早释放，提高内存利用率
构造代码块，在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
静态代码块， 在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。一般用于加载驱动。
同步代码块(后面多线程部分会讲解)

1public class BlockTest01  {
2    public static void main(String[] args) {
3        //局部代码块
4        {
5            int x = 10;
6            System.out.println(x);
7        }    
8        //System.out.println(x);
9
10        Student s1 = new Student();
11        System.out.println("------------");
12        Student s2 = new Student();
13    }
14
15    static{
16        System.out.println("BlockTest01中的静态代码块");
17    }
18}
19
20class Student {
21
22    public Student(){
23
24        System.out.println("构造方法");
25    }    
26    
27    //构造代码块
28    {
29        System.out.println("构造代码块");
30    }
31    
32    static{
33        System.out.println("静态代码块");
34    }

View Code

先执行静态代码块  局部代码块  构造代码  构造方法

继承：extends

1子类不能访问父类中private修饰的方法
2
3public class Test01 {
4    public static void main(String[] args) {
5        SubClass s = new SubClass();
6        s.m1();
7        //s.m2();//error子类不能访问父类中private修饰的方法
8        s.m3();
9        s.m0();//子类可以访问到其祖先类的方法
10    }
11}

重写**，**也叫做覆盖，当父类中的方法无法满足子类需求时，子类可以将父类的方法进行重写编写来满足需求。比如孩子继承了父亲的房子，可以将房子重新装修。
方法重写的条件：

• 两个类必须是继承关系
• 必须具有相同的方法名，相同的返回值类型，相同的参数列表.
• 重写的方法不能比被重写的方法拥有更低的访问权限。
• 重写的方法不能比被重写的方法抛出更宽泛的异常。
• 私有的方法不能被重写。
• 构造方法无法被重写，因为构造方法无法被继承。
• 静态的方法不存在重写。
• 重写指的是成员方法，和成员变量无关。

super 关键字  调用父类方法 或 变量

1public class Dog extends Animal {
2    public String name = "旺财";
3
4    public void eat(){
5    
6        System.out.println("吃狗粮");
7    }
8
9    public Dog(){
10        //super("土豪金","藏獒");super()
11        System.out.println("Dog中的无参构造方法");
12    }
13
14    public void m1(){
15        System.out.println(super.name);
16        System.out.println(this.name);//可以不加this
17        super.eat();
18        this.eat();//可以不加this
19    }
20}

多态：  不同实例调用相同方法时返回值却不相同

1public class AnimalTest01 {
2    public static void main(String[] args) {
3        Cat c1 = new Cat();
4        c1.eat();
5
6        Animal a1 = new Cat();//父类引用指向子类对象，自动类型转换，也叫做向上转型
7        a1.eat();//动态绑定和静态绑定
8        //System.out.println(a1.num);//结果10，说明成员变量不存在重写
9        //a1.move();
10
11        Cat c2 = (Cat)a1;//强制类型转换，也叫做向下转型
12        c2.move();
13
14        Animal a2 = new Dog();
15        if(a2 instanceof Cat){
16            Cat c4 = (Cat)a2;    
17        }else{
18            System.out.println("a2不是Cat类型");
19        }
20        //Cat c3 = (Cat)a2;//error ClassCastException类转型错误
21    }
22}

View Code

成员变量不存在重写

final：

final修饰的类无法被继承。
final修饰的方法无法被重写。
final修饰的局部变量，一旦赋值，不可再改变。
final修饰的成员变量必须初始化值。

1public class FinalTest01{
2
3    public final int k = 10;
4    
5    //常量，标识符大写
6    public static final double PI = 3.14;
7
8    public static void main(String[] args){
9        /*
10        final int i = 10;
11        i = 20;
12        */
13    }
14}

final修饰的基本数据类型，值不能改变
final修饰的引用数据类型，指向地址是不能改变的，但是对象里面的值是可以改变的

**抽象类：**abstract

1public abstract class A{
2
3    public A(){
4    
5        System.out.println("class A");
6    }
7    
8    //抽象方法
9    public abstract void m1();
10
11    public static void main(String[] args){
12        //A a = new A();//抽象类不能被实例化
13        A a = new B();
14        a.m1();
15    }
16}
17
18class B extends A{
19
20    public void m1(){
21        System.out.println("class B中的m1方法");
22    }
23
24    public B(){
25        super();
26        System.out.println("class B");
27    }
28}