Java面向对象

成员变量

       成员变量分两种： - 实例变量：没有static修饰，属于对象的，存储在堆中，有几个对象就有几份 ​ 通过对象/引用打点来访问 - 静态变量：有static修饰，属于类的，存储在方法区中，只有一份 ​ 常常通过类名点来访问。

Java四种访问权限

四种权限对比

关键字	汉语理解	访问权限	大小排行（从大到小）
public	公开的	任何类	1
protected	受保护的	本类、派生类（子类）、同包类	2
private	私有的	本类	4
default	默认（不写访问权限关键字）	本类、同包类	3

注：1.Java并不建议使用默认访问权限

        2.类的访问权限只能是public或默认的，类中的成员访问权限都可以。 

       3.属性一般都使用private，通过getter（）和setter（）来调用（即封装性，只对外提供接口）

方法一般都用public。

 class Card{ //银行卡
         private String cardId;  //卡号
         private String cardPwd; //密码
         private double balance; //余额
         
         public boolean payMoney(double money){ //支付金额---收银员可以调用
             if(balance>=money){
                 balance-=money;
                 return true;
             }else{
                 return false;
             }
         }
         public boolean checkPwd(String pwd){ //检测密码--营业员可以调用
             if(pwd和cardPwd相同){
                 return true;
             }else{
                 return false;
             }
         }
     }

//访问控制符的演示
     public class Aoo {
         public int a;     //任何类
         protected int b;  //本类、派生类、同包类
         int c;            //本类、同包类
         private int d;    //本类
     
         void show(){
             a = 1;
             b = 2;
             c = 3;
             d = 4;
         }
     }
     
     class Boo{ //---------------------演示private
         void show(){
             Aoo o = new Aoo();
             o.a = 1;
             o.b = 2;
             o.c = 3;
             //o.d = 4; //编译错误
         }
     }
     
     package ooday05_vis;
     import ooday05.Aoo;
     public class Coo { //---------------演示同包
         void show(){
             Aoo o = new Aoo();
             o.a = 1;
             //o.b = 2; //编译错误
             //o.c = 3; //编译错误
             //o.d = 4; //编译错误
         }
     }
     
     class Doo extends Aoo{ //跨包继承---------演示protected
         void show(){
             a = 1;
             b = 2;
             //c = 3; //编译错误
             //d = 4; //编译错误
         }
     }

包（package）

类的全称：包名.类名

建议：包名命名所有字母小写

导入类

同包中的类可以直接访问即可；不同包的类需要先导入再使用类

import 包名.*表示包中的所有类，不建议这样导入，这样会影响性能，应该需要哪个导入哪个。

final关键字

       当其单独出现时，修饰的变量为不可变变量，一般单独使用；配合static使用,如下，表示常量，注意常量通常需要字母全部大写（建议），常量在声明的同时初始化

private static final int A=18;

       汉语意思为最终的，也就是相当于论文定稿，不能再做修改，在Java中即它修饰的变量不能再被改变，它修饰的方法不能被重写，它修饰的类不能被继承，但它可以继承其他类（帮助理解：可以当儿子但不能当爸爸）

class Eoo{
         int a = 5;
         final int b = 5;
         void show(){
             a = 55;
             //b = 55; //编译错误，final修饰的变量，不能被改变
         }
     }
     ```

   - 修饰方法：方法不能被重写

  
     class Foo{
         void show(){}
         final void test(){}
     }
     class Goo extends Foo{
         void show(){}
         //void test(){} //编译错误，final修饰的方法，不能被重写
     }
     

   - 修饰类：类不能被继承

   
     final class Hoo{}
     //class Ioo extends Hoo{} //编译错误，final的类不能被继承
     class Joo{}
     final class Koo extends Joo{} //正确

static关键字

汉语静态的，即此关键字修饰的变量为静态变量

static关键字
静态变量	都由static关键字修饰	属于类，存储在方法区，只在第一次加载类时产生对象，之后再给静态变量操作，会替换，但不会加新的对象；没有隐式this所以不能直接访问；通过类名.变量（方法）来访问。	所有对象共享数据（图片、音频、视频）
静态方法			方法的操作与对象无关时可以使用
静态块		在类被加载时自动执行，因为一个类只加载一次，所以静态块也只执行一次	主要用于给静态变量赋值

 //演示静态变量
       class Loo{
           int a;
           static int b;
           Loo(){
               a++;
               b++;
           }
           void show(){
               System.out.println("a="+a+",b="+b);
           }
       }
       
       public class StaticDemo {
           public static void main(String[] args) {
               Loo o1 = new Loo();
               o1.show();
               Loo o2 = new Loo();
               o2.show();
               Loo o3 = new Loo();
               o3.show();
               System.out.println(Loo.b); //常常通过类名点来访问
           }
       }

   class Moo{
           int a; //实例变量(对象来访问)
           static int b; //静态变量(类名来访问)
           void show(){ //有隐式this
               System.out.println(this.a);
               System.out.println(Moo.b);
           }
           static void test(){ //没有隐式this
               //静态方法中没有隐式this传递
               //没有this就意味着没有对象
               //而实例成员a必须通过对象来访问
               //所以如下语句会发生编译错误
               //System.out.println(a); //编译错误
               System.out.println(Moo.b);
           }
       }
       //演示静态方法的应用场景
       class Noo{
           int a; //实例变量---描述对象的属性
           //show()方法中需要访问对象的属性a，说明show()的操作与对象有关---不能静态方法
           void show(){
               System.out.println(a);
           }
           //plus()方法中不需要访问对象的属性和行为，说明plus()的操作与对象无关-可以静态方法
           static void plus(int num1,int num2){
               int num=num1+num2;
               System.out.println(num);
           }
       }
       public class StaticDemo {
           public static void main(String[] args) {
               Noo.plus(5,7); //常常通过类名点来访问
           }
       }

//演示静态块
       class Poo{
           static{
               System.out.println("静态块");
           }
           Poo(){
               System.out.println("构造方法");
           }
       }
       public class StaticDemo {
           public static void main(String[] args) {
               Poo o4 = new Poo();
               Poo o5 = new Poo();
           }
       }

内存管理

 由JVM来管理

  - 堆：new出来的对象(包括实例变量、数组的元素)

  - 栈：局部变量(包括方法的参数)

  - 方法区：.class字节码文件(包括静态变量、所有方法)。