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学习总结(基础1)_第1张图片

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

三、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** : 对同一包内的类和所有子类可见。使用对象:变量、方法。 注意:不能修饰类(外部类)

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

Java学习总结(基础1)_第2张图片

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 算术运算符

Java学习总结(基础1)_第3张图片

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 关系运算符

 Java学习总结(基础1)_第4张图片

 7.3 位运算符

A = 0011 1100
B = 0000 1101

 Java学习总结(基础1)_第5张图片

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

 7.4 逻辑运算符

Java学习总结(基础1)_第6张图片

 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 赋值操作符

Java学习总结(基础1)_第7张图片

 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)

如有错误请评论区指点,感谢!

你可能感兴趣的:(JAVA,java,开发语言)