JAVA基础语法

1. 类

---

2. 局部变量

---

 定义： 定义在方法中的变量成为局部变量

作用域：从定义的位置开始到整个方法结束

注意：局部变量只能在当前方法中使用，其他地方无法使用

内存存放位置：存放在栈内

默认值： 局部变量无默认值；如果木有使用当前变量时，可以不赋值

2.1成员变量

---

 定义：定义在方法外、类内的变量叫成员变量(全局变量)

作用域：在整个类体内

注意：

内存存放位置：存放在堆内存中

默认值：成员变量有默认值；int->0 ;String->null ; boolean->false

示例：

public class Student {

    public int age = 20; //成员变量
    public String  addr; //成员变量有默认值；存放在堆内存，对整个类生效

    public void show(){
        String name = "xiaobai"; //局部变量，必须有默认值；只对当前方法有效；存放在栈中
        System.out.println("我的名字--"+name + ",年龄是--"+ age);
        System.out.println("addr 值是" + addr);
    }

    public static void main(String[] args){
        Student stu = new Student();
        stu.show();
//        System.out.println(age); //main函数使用成员变量需要加static关键字修饰
    }
}

 运行结果：

默认的无参构造函数
我的名字--xiaobai,年龄是--20
addr 值是null

3.构造方法

---

 定义：

      创建对象的时候会默认调用构造方法（在堆中开辟空间）,可以完成成员变量的某些初始化操作

构造方法语法：

        方法名称：构造方法的方法名称必须跟类的名称保持一致

        访问修饰符：待定

        形参：可以用户自定义添加，跟方法的普通参数一样

       方法体：完成对象的初始化功能

        返回值：无返回值

注意：

        1.创建类之后，若没有手动调用构造方法，会默认生成一个无参的构造方法供调用

         2. 当用户自定义了构造方法之后，默认的无参构造方法就不能使用了，需要手动定义无参构造方法

        3. 同一个类中可以包含多个同名的构造方法

        4. 一般构造方法都会进行重载（一个类中可能包含多个属性，只需要给部分属性初始化的时候需要调用不同的构造方法）

 示例：

public class Teacher {

    String name;
    int age;

    public Teacher(){
        System.out.println("无参构造方法");
    }

    public Teacher(String name){
        System.out.println("自定义构造方法，name值是:"+name);
    }

    public Teacher(int age,String name){
        this.age = age;
        this.name = name;
        System.out.println("two 构造方法，name is:" + name + "age is :"+ age);
    }

    public static void main(String[] args){
        Teacher t1 = new Teacher();
        t1.name = "lian";
        t1.age = 18;
        System.out.println("无参构造方法..."+ t1.age);
        Teacher t2 = new Teacher("xiaoxiao");
        Teacher t3 = new Teacher(29,"lisi");
        System.out.println("one argument..."+t2.name);
        System.out.println("two argument..." + t3.name + "---" + t3.age);
    }
}

运行结果：

无参构造方法
无参构造方法...18
自定义构造方法，name值是:xiaoxiao
two 构造方法，name is:lisiage is :29
one argument...null
two argument...lisi---29

4. 重载

---

 定义： 

         在一个类中可以包含多个重名的方法，但注意：方法的参数列表不能相同

三个方面的不同：

          参数个数不同、参数类型不同、参数顺序不同

5. this

---

作用： this代表当前对象本身，指向当前对象

用处：

     1. 构造方法：当构造方法中的参数名称跟类的成员变量名称一样，可以使用this代表当前对象

     2. 普通方法：当多个普通方法之间进行调用，可以使用this进行调用；指的是当前对象的其他方法

    3. 成员变量的使用：当方法中的参数名称跟成员变量一致时，使用this.变量名称表示的是对象的值；而使用变量名称表示形参列表的值

示例：

public class User {

    int age;
    String name;

    public User(int age){
        this.age = age; //局部变量的age赋值给成员变量;若不指定，则打印默认值 0
        System.out.println("构造方法..." + age);
    }

    public static void  main(String[] args){
        User user = new User(18);
        System.out.println("age is :" + user.age); //调用的是成员变量age
    }
}

public class User {

    int age;
    String name;

    public User(int age){
        this.age = age; //局部变量的age赋值给成员变量;若不指定，则打印默认值 0
        System.out.println("构造方法..." + age);
    }

    //方法1
    public void show(){
        System.out.println("show1");
    }

    //方法2
    public void say(){
        System.out.println("say");
        this.show(); //也可以不使用this，调用show方法
    }

    public static void  main(String[] args){
        User user = new User(18);
        System.out.println("age is :" + user.age); //调用的是成员变量age
        user.say();
    }
}

public class User {

    int age;
    String name;

    public User(int age,String name){
        this.age = age; //局部变量的age赋值给成员变量;若不指定，则打印默认值 0
        this.name = name;
        System.out.println("构造方法..." + age);
    }

    //方法1
    public void show(){
        System.out.println("show1");
    }

    //方法2
    public void say(String name){
        System.out.println("say");
        this.show(); //也可以不使用this，调用show方法
        System.out.println(name); //局部变量的值
        System.out.println(this.name); //成员变量的值
    }

    public static void  main(String[] args){
        User user = new User(18,"zhansan");
        System.out.println("age is :" + user.age); //调用的是成员变量age
        user.say("lisi");
    }
}

运行结果：

构造方法...18
age is :18
say
show1
lisi
zhansan

6. static

---

 定义：

     修饰成员变量时，表示 静态成员变量 或者叫 类变量

     普通变量在使用时，必须通过对象进行调用；

     类变量 或 静态变量可以通过对象调用，也可以通过类名进行调用

注意：

     静态变量在创建对象之前被初始化；或 在类被载入之前进行初始化

     静态变量被所有的对象共享，属于公共变量，对象和类都可以直接调用，但是推荐使用类来调用

存储位置： static变量置于方法区。

示例：

public class StaticDemo {
        String name = "zhangsan";
        static  int age = 10;

        public static void main(String[] args){
            StaticDemo sd = new StaticDemo();
            System.out.println(sd.age); //对象调用
            System.out.println(StaticDemo.age); //类名调用

            sd.age = 20;
            System.out.println(sd.age);
            System.out.println(StaticDemo.age);

            StaticDemo.age = 30;
            System.out.println(sd.age);
            System.out.println(StaticDemo.age);

            StaticDemo sd1 = new StaticDemo();
            System.out.println(sd1.age);
            System.out.println(StaticDemo.age);
        }

}

运行结果： 当修改当前成员变量值时，修改的是同一空间内的值。

10
10
20
20
30
30
30
30

7. 代码块

---

 定义：使用{}的代码叫做代码块

分类：

     普通代码块：定义在方法中，使用{}括起来的代码叫普通代码块

     构造代码块：定义在类中使用{}括起来的代码叫构造代码块； 

              注意：a. 每次代码运行时，会将 构造代码块中的代码 添加到 构造方法 前 ;

                         b. 优先运行构造代码块，再运行构造方法

                         c. 构造代码块中的代码会添加到每一个构造方法中，当使用this()时不会添加 this(age)，调用带一个参数的构造方法

     静态代码块： 使用static{}括起来的代码叫静态代码块，在创建对象前优先执行静态代码块

            注意：静态代码块中不能访问非static成员（因为非static成员是通过对象调用的，这时对象还未创建）

     同步代码块：在多线程时会使用，用来给共享空间进行加锁操作

执行顺序：静态代码>>> 构造代码块(创建对象时使用)>>>普通代码块

示例：

public class CodeBlockDemo {
    int age;
    String name;

    static {
        System.out.println("静态代码块");
    }

    {
        System.out.println("构造代码块...");
    }

    public CodeBlockDemo(){
        System.out.println("构造方法...");
    }

    public CodeBlockDemo(int age){
        this.age = age;
    }

    public CodeBlockDemo(int age, String name){
        this(age);
        this.name = name;
    }

    public void test(){
        System.out.println("test...");
        {
            System.out.println("普通代码块....");
        }
    }

    public static void main(String[] args){
        CodeBlockDemo cbd = new CodeBlockDemo(18,"aa");
        cbd.test();
        System.out.println("main...");
    }
}

运行结果：

静态代码块
构造代码块...
test...
普通代码块....
main...

8. 封装

---

 概念： 将类的某些信息隐藏在类内部，不运行外部程序直接访问；而是通过类提供的方法来实现对隐藏信息的操作和访问

 作用： 使用封装可以保证数据的规范，不符合规范的数据将无法进行操作

示例：

package com.xiuxianxiaoyu;

public class Dog {

    private int age; //私有属性
    private String name;
    private String color;

    //需要通过set/get类设置、获取属性值
    public void setAge(int age){
        if (age >0){
            this.age = age;
        }else {
            System.out.println("年龄输入不合法");
        }
    }
    public int getAge(){
        return this.age;
    }

    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }

    public void setColor(String color){
        this.color = color;
    }
    public String getColor(){
        return this.color;
    }

    public void show(){
        System.out.println("my dog name is :" + name + ", age is :" + age +", color is :" + color);
    }


}

package com.xiuxianxiaoyu;

public class DogDemo {
    public static void main(String[] args){
        Dog dog = new Dog();
        dog.setAge(18);
        dog.setName("xiaohei");
        dog.setColor("yellow");
        dog.show();
    }
}

运行结果：

my dog name is :xiaohei, age is :18, color is :yellow

8.1 访问限制

---

 限制访问，以下分类按照访问权限从大到小排列：

public: 公共的，当前项目的所有类都可以访问。

protected:受保护的；可以被当前类访问、可以被当前包访问、可以被子类访问。

default:默认权限；可以被当前类访问、可以被当前包访问。

private:只能被当前类访问。

注意：
   4种访问修饰符可以修饰 属性和方法；
   类的访问修饰符只有2种  public 和 default

8.2 形参、实参

---

 java中的参数传递都是值传递

    形参： 方法中的参数列表叫形式参数，没有具体的值，只是为了方便在方法体中使用；

   实参： 调用方法是实际传入的参数，代表具体的数值，用来替换在方法体中代码逻辑值的运算

    注意：

              1. 形式参数的变量名称也是局部变量

              2. 当方法的参数值是基本数据类型时，不会改变原来的值

              3. 当方法的参数值是引用类型的时候，如果改变了该引用类型的值，会改变原来对象的值

示例：

package com.xiuxianxiaoyu;

public class ArgmentDemo {

    public static void test(int a, int b){
        int tmp = a;
        a = b;
        b = tmp;
        System.out.println("test 方法中a=" + a + ",b=" + b );
    }

    public static void test2(Point p){
        int x = p.getX();
        int y = p.getY();
        int tmp = x;
        x = y;
        y = tmp;
        p.setX(x);
        p.setY(y);
    }

    public static void main(String[] args) {
        int a = 10;  //这个地方的赋值是局部变量的赋值
        int b = 20;
        test(a,b);
        System.out.println("main方法中a=" + a + ",b="+b);

        Point p = new Point(2,3);
        test2(p);
        System.out.println("改变后的值：" + p.getX() + "..." + p.getY());
    }
}

Point类：

package com.xiuxianxiaoyu;

public class Point {
    private int x;
    private int y;

    public Point(int x, int y){
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }
}

9. 继承

---

 定义： 表示父类跟子类之间的关系；当两个类火灾多个类具备相同的属性和方法时，可以提取出来，变成父类； is a 的关系

使用：

    1. 使用extends关键字进行继承

    2. 使用继承关系之后，父类中的属性和方法都可以在子类中进行使用(非私有属性和私有方法)

    3. java中为单继承(如果包含多个父类，同时父类中包含重名方法，无法决定调用谁)

 super:
     是直接父类对象的引用

supper用途：

    1. 可以在子类中 调用父类中被 子类覆盖的方法

    2. 当supper在普通方法中使用的话，可以任意位置编写

    3. 当supper在构造方法中使用时，默认会调用父类的构造方法，一定将supper放在第一行

    4. 在构造方法中supper关键字和this()关键字不能同时出现

    5. 父类中私有的属性和方法都不能被调用，包括构造方法

    6. 子类的构造方法中都会默认使用supper关键字调用父类的构造方法

    7. 如果构造方法中显示的指定了super的构造方法，那么无参的构造方法不会被调用

总结：

     1. 在创建子类的对象时一定会优先创建父类对象

示例：

package com.xiuxianxiaoyu.extend;

public class Pet {

    private String name;
    private int age;
    private String gender;

    public Pet(){

    }
    public Pet(String name, int age, String gender){
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public void play(){
        System.out.println("play....");
    }
}

子类

package com.xiuxianxiaoyu.extend;

public class Dog extends Pet {

    private String sound;

    public Dog(){

    }

    public Dog(String sound){
        this.sound = sound;
    }

    public Dog(String name, int age, String gender, String sound){
        super(name,age,gender);
//        this(sound);  //不能跟supper同时出现
        this.sound = sound;
    }

    public String getSound() {
        return sound;
    }

    public void setSound(String sound) {
        this.sound = sound;
    }

    public void play(){
        super.play(); //先调用父类的play方法
        System.out.println("dog is playing...");
    }
}

package com.xiuxianxiaoyu.extend;

public class Cat extends Pet{
    private String color;

    public Cat(){

    }

    public Cat(String name, int age, String gender, String color){
       super(name,age,gender);
        this.color = color;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

测试类

package com.xiuxianxiaoyu.extend;

public class PetTest {

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.setName("哈士奇");
        System.out.println(dog.getName());
        dog.play();
    }
}

运行结果：

哈士奇
play....
dog is playing...

9.1 重写

---

 定义：必须存在继承关系，当父类中的方法无法满足子类需求时，可以选择使用重写的方式

注意：

      1. 重写表示的是子类覆盖父类的方法，当覆盖之后，调用同样的方法时会优先调用子类方法

      2.重写的方法名称、返回值类型、参数列表必须跟父类一致

      3.子类重写的方法不允许比父类的方法具备更小的访问权限

父类 public             子类 public

 父类 protected       子类 public protected    

父类 default            子类 public　protected     default　　 

     4. 父类的静态方法，子类可以进行调用；但子类不可重写

示例：

父类方法： 

@Override
public String  toString(){
     return "my name is " + this.name + ",my age is " + this.age+ ", my gender is " + this.gender;
    }

子类重写父类方法：

 public String toString(){
        return super.toString()+ ", my sound is " + this.sound;
    }

9.2  final用法

---

 final 可以修饰变量： 表示变量的值不可变

final 可以修饰方法：表示方法不可以被重写

final可以修饰类：表示类不可以被继承

10. 抽象类

---

 定义： java中的对象是对现实世界的具象化，但在现实世界中，某些类并不具备实例化的意义，因此可以定义为抽象类

使用： 1. 创建抽象类的时候需要添加 abstract 关键字

            2. 不能进行实例化，也就是不能new对象

            3. 抽象类中的某些方法需要子类进行更丰富的实现，父类实现没有意义，此时可以将抽象类的方式定义为抽象方法，没有具体实现，只包含方法名称、返回值、参数列表、访问修饰符

             4. 使用abstract关键字修饰的方法叫做抽象方法，可以不写方法的实现

             5. 子类在继承抽象父类时，必须要将父类中的抽象方法进行实现 或者 将子类也定义为抽象类

             6. 有抽象方法的一定是抽象类；但抽象类中不一定包含抽象方法

示例：

抽象类：

package com.xiuxianxiaoyu.abstracts;

public abstract class Pet {

    public String name;
    //抽象方法
    public abstract void print();
    public void play(){
        System.out.println("play....");
    }
}

子类：

package com.xiuxianxiaoyu.abstracts;

public class Dog extends Pet {

    //子类实现父类的抽象方法
    @Override
    public void print() {
        System.out.println("dog print...");
    }
}

11. 多态

---

定义： 对应同一个指令(调用同一个名称的方法),不同的对象给予不同的反应(不同的方法实现)

规范：

     1. 必须要有继承关系

     2. 子类方法必须要重写父类的方法

     3. 父类引用指向子类对象

目的：

　　　为了提高代码的扩展性和维护性

　　　方便代码逻辑的编写 

表现形式：

　　1. 父类作为方法的参数

       2. 父类作为方法的返回值类型

示例：

    父类：

 子类：

测试类：

package com.example.duotai;

public class Person {

    //父类作为子类的返回值
    public Pet play(int type){
        if (type == 1){
            return new Dog();
        }else if(type == 2){
            return new Cat();
        }else{
            return new Penguin();
        }
    }

    //父类作为子类的参数
    public void feed(Pet pet){
        pet.feed();
    }

    public static void main(String[] args) {
        Person p = new Person();
        p.feed(new Dog());
        Pet pet = p.play(3);
        if (pet instanceof Dog){
            System.out.println("buy dog!!");
        }else if (pet instanceof Cat){
            System.out.println("bug cat !!");
        }else {
            System.out.println("buy penguin!!");
        }

    }
}

12. 接口

---

 java中的继承关系是单继续，如果拥有多个父类时，可以考虑使用接口进行实现。

java中的接口具备广泛的使用：

　　1. 使用interface来修饰

　　2. 接口中可以包含多个方法，且方法跟抽象类中的抽象方法一致，可以不写实现，子类在实现时必须实现父类接口的逻辑；

　　3. 子类实现接口使用implements关键字

 特征：

　　1. 接口中的所有方法都是抽象方法，不能包含实现逻辑；

　　2. 接口中的所有方法的访问修饰权限都是public，默认不限权限，也是public，不是default

       3.接口不能实例化

       4. 接口的子类必须实现接口中的所有方法；跟抽象类不同，抽象类中的抽象方法必须被子类实现

　　5. 子类可以实现多个接口 （A implements B,C,D）

　　6. 接口中的变量都是静态常量，如果变量没有使用static关键字修饰，它也表示静态常量

　　7. 接口中的方法和常量无论是否添加public修饰，默认的权限有且仅有一个，public

       8. 接口代表一种能力，接口中仅有定义N个方法，子类在进行实现时，意味着具备了方法的能力

13. 总结

---

1. try-catch-finally中，finally块唯一不执行的情况是什么？

答：在try或者catch语句中调用了退出虚拟机的方法(system.exit(1))

示例：

public class TryTest{
        public static void main(String[] args){
            test();
        }
     
        public static void test(){
        try{
            System.out.println("try");
            int i = 1 / 0;
            System.exit(1);
        }catch(Exception e){
            e.printStackTrace();
            System.exit(1);
        }finally{
            System.out.println("finally");
        }
    }
}