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关键字修饰
    }
}

View Code

运行结果：

默认的无参构造函数
我的名字--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);
    }
}

View Code

运行结果：

无参构造方法
无参构造方法...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
    }
}

View Code

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();
    }
}

View Code

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");
    }
}

View Code

运行结果：

构造方法...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);
        }

}

View Code

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

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...");
    }
}

View Code

运行结果：

静态代码块
构造代码块...
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);
    }


}

View Code

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();
    }
}

View Code

运行结果：

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());
    }
}

View Code

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;
    }
}

View Code

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....");
    }
}

View Code

子类

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...");
    }
}

View Code

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;
    }
}

View Code

测试类

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();
    }
}

View Code

运行结果：

哈士奇
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....");
    }
}

View Code

子类：

package com.xiuxianxiaoyu.abstracts;

public class Dog extends Pet {

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

View Code

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!!");
        }

    }
}

View Code

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");
        }
    }
}

View Code