Java学习总结（基础1）

一个 Java 程序可以认为是一系列对象的集合，而这些对象通过调用彼此的方法来协同工作。下面简要介绍下类、对象、方法和实例变量的概念。

• 对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
• 类：类是一个模板，它描述一类对象的行为和状态。
• 方法：方法就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的：做什么，怎么做。
• 实例变量：每个对象都有独特的实例变量，对象的状态由这些实例变量的值决定。

 此外，在软件工程中，面向对象方法学的四基本思想为：对象，类，继承，消息通信；面向对象方法的三大特性为：封装，继承，多态；面向对象需要建立的三大模型为：对象模型、动态模型、功能模型。需要与以上四个概念分开。

public static void main(String[] args){ 内容 };

访问修饰符 关键字 返回类型 方法名 String类 字符串数组；

一、Java注释

Java 注释主要有三种类型：

• 单行注释   //这是单行注释
• 多行注释   /*这是多行注释*/：多行注释以 /*开始，以 */结束
• 文档注释   /**这是文档注释 */：文档注释以 /**开始，以 */结束

Java枚举类型：通过一枚一枚具体举例找到所需变量，enum后固定取值已定，只能在其中选择。

class FreshJuice {
   enum FreshJuiceSize{ SMALL, MEDIUM , LARGE }
   FreshJuiceSize size;
}
 
public class FreshJuiceTest {
   public static void main(String[] args){
      FreshJuice juice = new FreshJuice();
      juice.size = FreshJuice.FreshJuiceSize.MEDIUM  ;
   }
}

二、Java类与对象 

 Java类与对象：通过一张图

从上到下，我们知道《汽车》是一个类，所代表的是一系列车型的集合，即一个完整模板，模板有自定义状态和行为。对象是类细分后所形成的一套模型，比如白色涡轮增压保时捷飞翔，有状态：白色、行为：飞翔。

三、Java变量类型

一个类可以包含以下类型变量：

• 局部变量（Local Variables）：局部变量是在方法、构造函数或块内部声明的变量，它们在声明的方法、构造函数或块执行结束后被销毁，**局部变量在声明时需要初始化，否则会导致编译错误**。
• 实例变量（Instance Variables）：实例变量是在类中声明，但在方法、构造函数或块之外，它们属于类的实例，每个类的实例都有自己的副本，如果不明确初始化，实例变量会被赋予默认值（数值类型为0，boolean类型为false，对象引用类型为null）。
• 静态变量或类变量（Class Variables）：类变量是在类中用 static 关键字声明的变量，它们属于类而不是实例，所有该类的实例共享同一个类变量的值，类变量在类加载时被初始化，而且只初始化一次，静态变量可以用来存储整个程序都需要使用的数据，如配置信息、全局变量等。
• 参数变量（Parameters）：参数是方法或构造函数声明中的变量，用于接收调用该方法或构造函数时传递的值，参数变量的作用域只限于方法内部。

public void gayblack(){
   int age = 10;//局部变量，作用域在此方法中，在声明后必须初始化，否则编译不会通过，比如int age;
  }
public class ExampleClass {
  int instanceVar;//实例变量，可以不初始化，默认赋值0/FALSE/NULL
  }
public class ExampleClass {
  static int age = 10;/*类变量，只属于类，
静态变量在类加载时被创建，在整个程序运行期间都存在*/
  } 
public void setage(int parameterVar) {
    //参数变量，只在此方法中有用
  age = parameterVar;
  } 

public class RunoobTest { 
    private int instanceVar;// 成员变量   
    private static int staticVar;// 静态变量
    public void method(int paramVar) { //参数变量
        int localVar = 10;// 局部变量
        instanceVar = localVar;
        staticVar = paramVar;
        System.out.println("成员变量: " + instanceVar);
        System.out.println("静态变量: " + staticVar);
        System.out.println("参数变量: " + paramVar);
        System.out.println("局部变量: " + localVar);
    }
    public static void main(String[] args) {
        RunoobTest v = new RunoobTest();
        v.method(20);
    }
}

输出结果： 

成员变量: 10
静态变量: 20
参数变量: 20
局部变量: 10

 静态变量可以用来存储整个程序都需要使用的数据，如配置信息、全局变量等。

• 存储全局状态或配置信息
• 计数器或统计信息
• 缓存数据或共享资源
• 工具类的常量或方法
• 单例模式中的实例变量

如果一个静态变量依赖于另一个静态变量，那么它必须在后面定义。 

public class MyClass {
    public static int count = 0;
    // 其他成员变量和方法
}
MyClass.count = 10; // 通过类名访问
MyClass obj = new MyClass();
obj.count = 20; // 通过实例名访问

四、Java中的set和get方法

get()方法是用来获取指定的私有成员变量的值，set()方法是用来设置指定的私有成员变量的值，get和set方法是Java中的一个重要概念，用于访问和修改对象的属性。在类内部定义private限制变量的作用域，用set和get方法来改变变量的值，该机制隐藏了代码实现细节，体现了数据的封装性，保证了代码的安全，同时也提升了数据的安全性。在对set和get方法的实现中，可以使用一些限定条件提升数据精确度。

class Student{
  private string name;
  private int score;
  public void show(){
    System.out.println("我的名字是" + name + "，我的成绩是"+ score + "分。")

}
  public String getName(){
    return name;
}
  public void setName(String name){
    this.name=name;
}
  public int getScore(){
    return score;
}
  public void setScore(int score){
    if(score<0 && score >100){
      this.score = 0;
      } else{
      this.score=score;
}
}
}
public class Test{
  public static void main(String[] args){
    Student s1=new Student();
    Student s2=new Student();
    s1.setName("jack");
    s2.setName("black");
    s1.setScore(100);
    s2.setScore(60);
    s1.show();
    s2.show();
}
}

 五、Java基本数据类型

整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。

转换从低级到高级。

低  ------------------------------------>  高

byte,short,char—> int —> long—> float —> double 

 一个字节8位/两个字节16位/单一的16位Unicode字符/四个字节32位/八个字节64位/四个字节32位/八个字节64位

数据类型转换必须满足如下规则：

• 1. 不能对boolean类型进行类型转换。

• 2. 不能把对象类型转换成不相关类的对象。

• 3. 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。

• 4. 转换过程中可能导致溢出或损失精度，例如：

  int i =128;   
  byte b = (byte)i;

  因为 byte 类型是 8 位，最大值为127，所以当 int 强制转换为 byte 类型时，值 128 时候就会导致溢出。

• 5. 浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入，例如：

  (int)23.7 == 23;        
  (int)-45.89f == -45

 六、Java修饰符

6.1 访问控制修饰符

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

• default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。

• private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）

• public : 对所有类可见。使用对象：类、接口、变量、方法

• **protected** : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

我们可以通过以下表来说明访问权限：

protected关键需要理解的是同一包内和所有子类可见，这两点只要满足就可以。我们可以通过以下几个关于protected方法可见性的例子来进一步掌握protected关键字。

 代码1：对于(1)而言，clone()方法来自于类MyObject2本身，因此其可见性为包p2及MyObject2的子类，虽然Test2是MyObject2的子类，但在Test2中实例化myobj2不能访问基类MyObject2的protected方法clone()，因此编译不通过;对于(2)而言，由于Test2继承于基类MyObject2，在Test2类作用域内部实现clone()因此编译通过。

package p2;
class MyObject2 {
    protected Object clone() throws CloneNotSupportedException{
       return super.clone();
    }
}
 
package p22;
public class Test2 extends MyObject2 {
    public static void main(String args[]) {
       MyObject2 obj = new MyObject2();
       obj.clone(); // Compile Error         ----（1）
 
       Test2 tobj = new Test2();
       tobj.clone(); // Complie OK         ----（2）
    }
}

代码2：对于(1)而言，clone()方法来自于类MyObject5，因此其可见性为包p5及其子类(此处没有子类)，而类Test5也在包p5中，因此满足可见性，编译通过。

package p5;
 
class MyObject5 {
    protected Object clone() throws CloneNotSupportedException{
       return super.clone();
    }
}
public class Test5 {
    public static void main(String[] args) throws CloneNotSupportedException {
       MyObject5 obj = new MyObject5();
       obj.clone(); // Compile OK        ----(1)
    }
}

 代码3：对于(1)而言，clone()方法来自于类Object，因此该clone()方法可见性为包java.lang及其子类Test7，由于类MyObject7不在此范围内，因此不满足可见性，编译不通过。

package p7;
 
class MyObject7 extends Test7 {
    public static void main(String[] args) {
        Test7 test = new Test7();
        test.clone(); // Compile Error   ----- (1)
  }
}
 
public class Test7 {
}

 代码4：首先看(1)(3)，其中的f()方法从类Father1继承而来，其可见性是包p1及其子类Son1和Son11，而由于调用f()方法的类Test1所在的包也是p1，因此（1）(3)处编译通过。其次看(2)(4)，其中的clone()方法的可见性是java.lang包及其所有子类，对于语句"son1.clone();"和"son11.clone();"，二者的clone()在类Son1、Son11中是可见的，但对Test1是不可见的，因此（2）(4)处编译不通过。

package p1;
public class Father1 {
    protected void f() {}    // 父类Father1中的protected方法
}
 
package p1;
public class Son1 extends Father1 {}
 
package p11;
public class Son11 extends Father1{}
 
package p1;
public class Test1 {
    public static void main(String[] args) {
        Son1 son1 = new Son1();
        son1.f(); // Compile OK     ----（1）
        son1.clone(); // Compile Error     ----（2）
 
        Son11 son = new Son11();    
        son11.f(); // Compile OK     ----（3）
        son11.clone(); // Compile Error     ----（4）
    }
}

这里注意将代码4和代码1做对比，代码2和3容易理解。

6.2 非访问修饰符

为了实现一些其他的功能，Java 也提供了许多非访问修饰符。

static 修饰符，用来修饰类方法和类变量，局部变量不能被声明为 static 变量。类方法又叫static方法，是属于当前整个类的，而不是属于某个实例的，只能处理static域或调用static方法，类方法可以直接通过类名调用，不需要先初始化类的实例,如果一个静态变量依赖于另一个静态变量，那么它必须在后面定义。

public class Demo {
    public static int s=10；
    //类变量，所有对象共享同一份数据，可以通过类名来访问静态变量，也可以通过实例名来访问静态变量
    float a;
    //实例方法
     void sum(float num1,float num2){
       a = Max(num1,num2);
    }
    //类方法
    static  float Max(float num1,float num2){
        return num1 <= num2 ? num2 :num1;
    }
    public static void main(String[] args) {
        Demo demo =new Demo();
        demo.sum(22,33);  //实例方法必需先初始化类的实例，然后通过类的实例才能调用
        Demo.Max(12,9);   // 类方法可以直接通过类名调用
    }
}

final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的：final变量一旦赋值后，不能被重新赋值。被 final 修饰的实例变量必须显式指定初始值； final 方法可以被子类继承，但是不能被子类重写；final 类不能被继承，没有类能够继承 final 类的任何特性。

abstract 修饰符，用来创建抽象类和抽象方法，任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。

synchronized 和 volatile 修饰符，主要用于线程的编程，synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符。volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。

 七、Java运算符

 7.1 算术运算符

public class selfAddMinus{
    public static void main(String[] args){
        int a = 5;
        int b = 5;
        int x = 2*++a;
        int y = 2*b++;
        System.out.println("自增运算符前缀运算后a="+a+",x="+x);
        System.out.println("自增运算符后缀运算后b="+b+",y="+y);
    }
}

自增运算符前缀运算后a=6，x=12，++a是让a先自增之后再参与运算，最终a的值总要增。
自增运算符后缀运算后b=6，y=10，b++是让b先参与运算之后再自增，最终b的值总要增。

 7.2 关系运算符

 

 7.3 位运算符

A = 0011 1100
B = 0000 1101

 

 位运算符使用少，记住^：异或和>>>右移补零 使用方法即可，其他是常识。

 7.4 逻辑运算符

 7.5 短路逻辑运算符：(判断)&&(判断)

当使用与逻辑运算符时，在两个操作数都为true时，结果才为true，但是当得到第一个操作为false时，其结果就必定是false，这时候就不会再判断第二个操作了。

public class LuoJi{
    public static void main(String[] args){
        int a = 5;//定义一个变量；
        boolean b = (a<4)&&(a++<10);
        System.out.println("使用短路逻辑运算符的结果为"+b);
        System.out.println("a的结果为"+a);
    }
}

 解析： 该程序使用到了短路逻辑运算符(&&)，首先判断 a<4 的结果为 false，则 b 的结果必定是 false，所以不再执行第二个操作 a++<10 的判断，所以 a 的值为 5。

 7.6 赋值操作符

 7.7 条件运算符

b =  (a == 1) ? 20 : 30;//如果 a 等于 1 成立，则设置 b 为 20，否则为 30。

 7.8 instanceof 运算符

 该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。

String name = "James";
boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真

参考于菜鸟教程：菜鸟教程 - 学的不仅是技术，更是梦想！ (runoob.com)

如有错误请评论区指点，感谢！