实际含义是：该隐藏的隐藏，该暴露的暴露
全局变量：定义在类中的，所有方法都可以访问到，叫全局变量
局部变量：定义在一个方法里的，只有本方法可以访问的叫局部变量
? 权限修饰符（public) + 类型（void、int、string、array[]...） + 变量名称
注：变量名称要用合法的JAVA标识符，首单词的第一个字母小写，后面的每一个单词首字母大写
public static void test(int...a){
for(int i=0;i<a.length;i++){
System.out.println(a[i]);
}
}
当不确定参数内要传多少个时，用int... 在调用test方法时，可以任意传几个参数，同时会把a当作数组进行处理
注：
如果一个参数里有可变参数，并且有多个参数，那么可变参数一定要放在最后一个
public static void test(int b,int...a){
for(int i=0;i<a.length;i++){
System.out.println(a[i]);
}
}
（ 参数类型 参数名称 + , + 参数类型 参数名称） + { 代码体 + return 表达式 }
形式参数：在参数名称中，方法本身起的名字叫形式参数，只起一个代号的作用。
实际参数：在通过 . 调用方法时，依据形式参数传进的东西是实际参数。
不需要new对象就可以访问的方法封装：
? public static Person getPerson(){
? return new Person();
? }
方法封装的好处：1.方便维护 2.减少冗余代码的出现
作用：用于该类的实例对象的初始化
格式： public Person(){ }
示例： pubilc int size;
? pubilec Person(){
? size=18;
? }
this关键字总是指向该方法的对象。
作用：this关键字最大的作用就是让类中一个方法，访问该类里的另一个方法或Field
final关键字可以修饰类，可以修饰变量，可以修饰方法：
修饰类，类不能被继承
修饰变量，变量就变成了常量，只能被赋值一次 当修饰的变量是一个对象时，该对象不能改变（即不能将变量更改为另一个对象），但是对象中的内容可以改变
如：final StringBuffer a=new StringBuffer("abc");
? 执行 a=new StringBuffer(""); 会报错，因为又重新New了一个对象
? 但是执行 a.append("123"); 不会报错，因为对象没有改变，对象的内容发生变化是不影响的
修饰方法，方法不能被重写
代码： public void setSex(String sex){
? this.sex=sex;
? }
Demo demo=new Demo();
Student student=new Student("tom",18,6,"3333","男");
demo.save(student);
public void save(Student student){
? System.out.println(student.getName());
? System.out.println(student.getAge());
}
如上：Demo demo=new Demo();
? demo.save(new Student());
JAVA的参数传递方式只有一种，那就是值传递
值传递含义：就是将实际参数的复制品传进方法，也就是重新创建一个一模一样的参数，对这个复制品进行方法操作，而实际参数的本身并没有受到影响。
如：int a=5,b=5;
? public void change(int a, int b){
? a=100;
? b=100;
? }
public void change(int a, int b){
a=100;
b=100;
}
public static void main(){
int a=10;
change(a);
System.out.println(a);
}
//打印后a的值依旧是10，调用方法并没有改变，因为传进去的是基本类型的副本，只有引用类型才会传进地址，最后的值会被改变，如果用change方法改变a的值的话，需要在后面return
传进的是引用类型时：
public void change(StringBuffer buffer){
buffer.append("123");
}
public static void main(){
StringBuffer buffer=new StringBuffer("ABC");
change(buffer);
System.out.println(buffer);
}
//此时打印后结果为ABC123，因为传进去的是地址，原本的值会被修改
在此次方法操作中,a和b的值依旧是5，并没有变成100，就是对a与b的复制品进行了操作，实际参数本身没有改变
如果想要将ab变成100的话，就需要返回a与b，在后面加return ,并将void改为Int
只有基本类型的值传递才是将复制品传进方法，其他类型的值传递是传进地址值的复制品，所以是可以对实际参数进行修改的
方法名不可以重名，但是方法名相同时，参数列表不同时，如：方法一有两个参数，方法二有三个参数，尽管两个方法名字相同，但是可以同时存在，这叫方法的重载
重载只与方法名和参数名称有关，与权限修饰符，返回值类型等无关
方法名相同，参数名称不同或参数数量不同时，才叫重载
含义：自己调用自己
斐波那契数列：
1 1 2 3 5 8 13 21 34
假设要求第n位的值：
public int fb(int n){
? if(n1 || n2){
? return 1;
? }else{
? return fb(n-1)+fb(n-2);
? }
}
递归最重要的是找到第一个递归的出口
特点：
static是跟随类的出现而出现，类名出现一次，那么static后面的内容就会执行一次
被类的所有对象（new一次就是一个对象）共享：在调用static修饰的变量时，不同对象调用的是同一个变量，对象一对变量b进行改变时，对象二中的变量b也会改变而不同的对象调用不被static修饰的变量时，不同的对象使用的是不同的变量，对象一修改变量a时，对象二的变量a是不会被改变的
例如：
static int a=1;
public static void main(){
Num num1=new Num();
Num num2=new Num();
num1.a=2;
System.out.println(num2.a)
}
//此时打印的num2的a，它的值为2，因为两个对象共用的一个变量，num1做了修改,num2也会有改变
可以通过类名直接调用
注意事项
静态变量和成员变量的区别
用武之地
局部代码块：
构造代码块
静态代码块
多个类存在相同的属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为（也叫方法），只要继承这个类就可以了，这个类就是父类
父类与子类：
通过extends关键字实现继承
提高了代码的复用性
提高了代码的维护性
让类与类之间产生了关系，是多态的前提
JAVA只支持单继承，不支持多继承
JAVA支持多层继承（爷爷类）
子类只能继承父类非私有的成员（成员方法和成员变量）
子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法
要访问父类的构造就只能通过子类的构造方法去访问
//父类的空参构造：
public Pet(){
}
//通过子类访问父类构造：
public Dog(){
super();
}
//注：尽管在子类的构造方法中没有写super(); 但是已经默认写上了父类的空参构造
//父类的有参构造：
public name;
publci Pet(String name){
this.name=name;
}
//通过子类访问父类的有参构造：
public Dog(String name){
super(name);
}
子类中所有的构造方法默认都会访问父类空参的构造方法
不能通过 子类=new 父类
可以通过 父类=new 子类
super的用法和this很像
super用法：
子类中出现了和父类一模一样的方法声明，也被称为方法覆盖，方法复写
规则：
方法名相同，形参列表相同
子类方法返回值类型应该比父类方法返回值相等或者更小。
子类方法声明抛出的异常应该比父类方法更小或者相等
子类权限比父类权限大或者相等
补充：
有继承关系
有方法的重写
有父类引用指向子类对象
举例：
Pet pet=new Dog();
pet.eat();
Pet pet=new Cat();
pet.eat();
new Dog时打印出狗吃骨头,new Cat时打印出猫吃鱼
对外管理的是同样的pet对象，具体New哪一个类，在后面改就可以
提高了程序的维护性
提高了程序的扩展性
A类 instanceof B类
A类 instanceof A类
访问变量时，访问的是父类的变量
访问方法时，访问的是子类的方法
但是父类中要有和子类方法一样的方法名
如： 子类Dog类中有play这个方法，但是父类Pet类中没有该方法，所以是无法使用Dog类的play方法的
这就是多态的弊端：无法访问子类特有的功能
解决方法：转型
public static void change(Pet pet){
if(pet instanceof Dog ){
pet=(Dog)pet;
((Dog)pet).play();
}
if(pet instanceof Cat){
pet=(Cat)pet;
((Cat)pet).play();
}
}
访问静态方法时，访问的是父类的
抽象就是找出事物的相似和共性之处，然后将然后将这些事物归为一个类，这个类只考虑这些
事物的相似和共性之处，并且会忽略与当前主题和目标无关的那些方面，将注意力集中在与
当前目标有关的方面
当一个类没有具体信息，只是定义一些功能（就是要干嘛能干嘛），那么就把这个类定义为抽象类
抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
抽象类不能够被实例化
抽象类的子类：
成员变量：
构造方法：
成员方法：
private 冲突
final 冲突
static 无意义
定义一个类为接口：
public interface UserService{
public void insert();
public void delete();
}
用一个类实现一个接口：用 implements
public class UserService implements UserService{
public void insert(){
}
public void delete(){
}
}
对于变量来说：
对于方法来说：
对于构造方法：
接口不能被实例化
接口的子类
抽象类是一个类，子类要继承（extends）它， 接口是要被子类实现（implements），关键字不同
对于变量：
对于成员方法：
对于构造方法：
一个类可以实现多个接口，但只能继承一个抽象类
原文：https://www.cnblogs.com/rxz110010/p/15099900.html