Java语言基础

一.Java标识符命名规则

1、由26个字母、数字0~9、_、$组成

2、不可以由数字开头

3、不可以使用关键字和保留字，但是能包含关键字和保留字

4、Java中严格区分大小写，长度无限制

5、表示符不能包含空格

6、包名：所有字母小写

7、类名、接口名：所有单词的首字母大写

8、变量名、方法名：第一个单词首字母小写，第二个单词开始，每个单词首字母大写

二．运算符

Java语言中的运算符主要包括算术运算符、关系运算符、逻辑运算符、位运算符等。

1.算术运算符：Java中的算术运算符包括加、减、乘、除、取余五种运算符，分别用+、-、*、/、%表示。

2.关系运算符：Java中的关系运算符用于判断两个数之间的大小、相等或是不等关系。关系运算符包括大于、小于、等于、大于等于、小于等于、不等于6种运算符，分别用>、<、==、>=、<=、!=表示。

3.逻辑运算符：Java中的逻辑运算符包括与、或、非三种运算符，用&&、||、！表示。

4.位运算符：Java中的位运算符用于对二进制数进行操作。位运算符包括按位与、按位或、按位异或、取反、左移和右移等6种运算符，分别用&、|、^、~、<<、>>表示

三．循环结构

3.1  while循环结构

int i = 0;

while(   )

{

循环体;

   i++;

}

3.2  do-while循环

int i = 0;

do{

    循环体;

    i++;

}while(  );

3. 3  for循环

for(  )

{

    循环体;

}

4.3  break语句和continue语句

break语句：当break语句出现在循环语句(for、while和do…while)时，程序会跳出当前循环或switch语句，执行后续的代码。在嵌套的循环语句中，break语句只能跳出当前的一层循环，对于外层的循环不会有影响。

public class BreakDemo01 {

    public static void main(String[] args) {

        int i = 0;

while (i < 100) {     //使用while循环，循环条件为  i<100

            i++;

System.out.println(i);    //在控制台上输出i  的值

            if (i == 30){     //再写一个if判断，即变量i经过while循环之后，i=30的情况时

                break;      //跳出循环，终止程序

            }

        }

    }

}

而当continue语句出现在循环语句(for、while和do…while)时，程序会跳过当前循环中剩余的语句，直接执行下一次循环。在嵌套的循环语句中，continue语句只对当前层的循环生效。

public class Demo02 {

    public static void main(String[] args) {

        int i = 0;

        while (i < 100) {

            i++;                //逐次加一

            if (i % 10 == 0) {

                System.out.println();     //输出

                continue;       //碰到continue，循环就再一次跳到循环开始的地方

            }

            System.out.print(i);     //输出i  的赋值

//continue语句在循环语句中，用于终止某一次循环过程，        

        }

    }

}

四．方法

4.1  方法的定义和调用

public static void 方法名{

//方法的内容}

实例：public class test {

    public static void main(String[] args) {

        hello();//在同一类下，静态成员之间的访问直接通过  方法名();}

     public static void hello(){

        System.out.println("hello world");

}

}

4.2  带参数方法的定义和调用

public static void 方法名(参数){

//方法内容

}

例：public class  {

    public static void main(String[] args) {

        compare(10,20);

    }

    public static void compare(int a,int b){

        System.out.println(a>b?a:b);

    }

}

4.3  带返回值的参数方法定义和调用

public  static 返回类型 方法名(参数){

//方法

return 数据

}

例：public class 比较 {

    public static void main(String[] args) {

       int a=compare(10,20);

        System.out.println(a);

    }

    public static int compare(int a,int b){

       return a>b?a:b;

    }

}

五．类与对象 

5.1  在Java中，通过定义类来创建对象。类的定义包含了属性和方法。属性是描述对象特征的变量，而方法是描述对象行为的函数。

public class A {

    // 属性

    private String name;

    private int age;

    // 构造方法

    public Person(String name, int age) {

        this.name = name;

        this.age = age;

    }

    public void abc() {

        System.out.println("Hello, my name is " + name + ". I am " + age + " years old.");

    }

}

在上面的例子中，我们定义了一个名为A的类，它有两个属性：name和age。构造方法用于创建对象时初始化属性的值。而abc()方法用于输出对象的信息。

通过创建对象并访问属性和调用方法

public class Main {

    public static void main(String[] args) {

        // 创建Person对象

        Person person = new Person("John", 25);

        // 访问属性

        System.out.println(person.name);

        // 调用方法

        person.sayHello(); // 输出: Hello, my name is John. I am 25 years old.

    }

}

5.2  类的构造方法

1.构造方法没有返回值类型，也不需要写返回值。因为它是用于构建对象，对象创建完后，方法就执行结束

2.构造方法名称必须和类型保持一致

3.构造方法没有具体的返回值

5.3  修饰符

表1 各种访问修饰符的可访问性
访问范围	private	friendly	protected	public
同一个类	可访问	可访问	可访问	可访问
同一包中的其他类	不可访问	可访问	可访问	可访问
不同包中的子类	不可访问	不可访问	可访问	可访问
不同包中的非子类	不可访问	不可访问	不可访问	可访问

六．类的封装

为了不让其他类直接访问类的属性，需要对类进行封装，避免对象属性赋值的随意性。

6.1类的基本封装

6.1.1   通过使用四个修饰符来对类的属性和行为进行不同的访问权限

        default (默认）：在同一包内可见，不使用任何修饰符。

        private : 在同一类内可见，但是不能修饰——外部类

        public : 对所有类可见。

        protected : 对同一包内的类和所有子类可见，不能修饰——外部类

6.1.2   将属性私有化后对外提供属性的访问方法，分别是赋值方法和取值方法。

赋值方法，提供 set方法。

取值方法，提供 get方法。

如果私有化属性之后，如果提供了set方法或提供了get方法则对对象进行取值或者赋值。

6.3  this关键字

this关键字的作用为解决局部变量和成员变量的问题

6.4  构造方法

        构造方法的特点

        构造方法没有返回值类型。也不需要写返回值。因为它是为构建对象的，对象创建完，方法就执行结束。

        构造方法名称必须和类型保持一致。

        构造方法没有具体的返回值。

七.  类的继承

7.1  为什么要对类进行继承

类继承的优点：

1.避免重复编写相同的代码，提高了代码的复用性。

2.创建一个子类，并在子类中添加新的属性和方法，从而扩展父类的功能，使程序更加灵活和可扩展。

3.通过继承，可以通过抽象类或接口定义一组共享的属性和方法

7.2  继承的使用

类只支持单继承，一个类只能有一个直接父类，但是可以进行多层继承

7.3  子父类中成员变量、方法的特点

在子类中访问其他成员（成员变量、成员方法）时依据就近原则进行继承

super关键字

        如果子类中出现了父类中同名的成员变量，这时子类中若要访问父类中的成员变量，必须使用关键字super来完成

class Animal {
    void eat() {
        System.out.println("animal : eat");
    }
}

class Dog extends Animal {
    void eat() {
        System.out.println("dog : eat");
    }
    void eatTest() {
        this.eat();   // this 调用自己的方法
        super.eat();  // super 调用父类方法
    }
}

public class Test {
    public static void main(String[] args) {
        Animal a = new Animal();
        a.eat();
        Dog d = new Dog();
        d.eatTest();
    }
}

在子类重写父类的方法时，需要注意

1.子类方法覆盖父类方法时，必须保证权限大于等于父类权限

2.子类和父类方法声明时必须一样

八.抽象类与接口

8.1  抽象类

8.1.1抽象方法、抽象类的定义格式

public abstract 返回值类型 方法名(参数);

abstract class 类名 {  语句 }

public abstract class A{

    public abstract void test();
}

8.1.2  抽象类的特点

1.抽象类和抽象方法都需要abstract修饰。

2.抽象类不可以直接创建对象。

3.只有覆盖了抽象类中所有抽象方法后，其子类才可以创建对象。

4.抽象类中可以不定义抽象方法。

8.2  接口

8.2.1  接口的格式

public interface 接口名{抽象方法3、抽象方法2、抽象方法3、

}

8.2.2  接口的多继承

在Java中，类的多继承是不合法，但接口允许多继承。

在接口的多继承中extends关键字只需要使用一次，在其后跟着继承接口。

public interface A extends B, C

8.3  接口和抽象类的异同

相同之处：

        都可以用来实现多态性：通过接口或抽象类的引用，可以引用其实现类的对象，并调用相应的方法。

不同之处：

1. 实现方式：抽象类使用继承来实现，一个类只能继承一个抽象类，而接口使用实现来实现，一个类可以实现多个接口。
2. 方法体：抽象类可以包含具体的方法实现，而接口只能包含方法的签名，没有方法体。
3. 构造函数：抽象类可以有构造函数，而接口不能有构造函数。
4. 成员变量：抽象类可以有实例变量和静态变量，而接口只能有常量（public static final）。

九.类的多态

9.1  多态使用格式与实例：

父类类型  变量名 = new 子类类型();
变量名.方法名();

public class Demo {
    public static void main(String[] args) {
        Animal a = new Cat();
        a.eat();
    }
}
 
class Animal {
    public void eat() {
        System.out.println("吃东西");
    }
}
 
 
class Cat extends Animal {
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

9.2  多态中向上转型与向下转型

多态的转型分为向上转型与向下转型两种：

        向上转型：当有子类对象赋值给一个父类引用时，便是向上转型.

使用格式：

父类类型  变量名 = new 子类类型();

如：Person p = new Student();

        向下转型：一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用转为子类引用，这个过程是向下转型。

使用格式：

子类类型 变量名 = (子类类型) 父类类型的变量;

如：Student st = (Student) l;