Java 基础（二）

类的初始

类中包括：属性，方法。

快速使用

我们都是人，而人的共同特点有很多。

比如：名字，年龄，性别，吃饭，睡觉。。。

// 定义类
public class Person {
    // 定义属性
    String name, gender;
    int age;

    // 构造方法
    public Person(String name, String gender, int age){
        this.name = name;
        this.gender = gender;
        this.age = age;
    }
    
    // 定义方法
    public void eat(){
        System.out.println("在吃饭");
    }
    public void sleep(){
        System.out.println("在睡觉");
    }
}

类的属性

属性就好像人的特征，如：姓名，年龄，性别

声明：

按照变量的声明规则，进行声明即可。也称之为局部变量

类的方法

在 Java 语法中，函数也被称为方法，因为是定义在类下。

一个类可以有多个方法，但是方法下不能嵌套方法。

声明：

/*
访问修饰符 返回值类型 方法名(参数列表)｛
　　逻辑
}
*/

返回值类型，void 表示没有返回值。

构造方法

名称与类名相同
没有返回值类型，也不需要void
创建对象时，自动调用

public class Person {
    // 定义属性
    String name, gender;
    int age;

    // 构造方法
    public Person(String name, String gender, int age){
        this.name = name;
        this.gender = gender;
        this.age = age;
    }
}

方法重载

多个方法相同，根据参数类型位置进行传参。

允许类中的方法名一致。
参数不能相同。
和修饰符，返回值无关。

class Person {
    public void show() {
        System.out.println("没有参数的show方法");
    }

    public void show(String name) {
        System.out.println("我叫：" + name);
    }

    public void show(int age) {
        System.out.println("今年：" + age);
    }
}

class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.show();
        person.show("SPC");
        person.show(18);
    }
}

无限传参

将形参变量前加 ... 即可
位置必须放在，其它形参之后。

class Demo{
    // 程序入口
    public static void main(String[] args){
        System.out.println(add(1,2,3)); // 6
    }
    // 多值相加
    public static int add(int ...args){
        int sum = 0;
        for (int i = 0; i < args.length; i++) {
            sum += args[i];
        }
        return sum;
    }
}

实例化对象

类：就像一个模板。

对象：根据这个模板，产出的对象。

如：张三，李四，他们的名字不一样，但是他们是人，都有属于自己的名字。

快速使用

Person.java

public class Person {
    // 定义属性
    String name, gender;
    int age;

    // 构造方法
    public Person(String name, String gender, int age){
        this.name = name;
        this.gender = gender;
        this.age = age;
    }

    // 定义方法
    public void eat(){
        System.out.println(this.name + "在吃饭");
    }
    public void sleep(){
        System.out.println(this.name + "在睡觉");
    }
}

Demo.java

public class Demo {
    public static void main(String[] args){
        Person zhangsan = new Person("张三", "男",22); // 实例化对象
        zhangsan.eat(); // 调用 zhangsan 对象的方法
        zhangsan.sleep();

        Person lisi = new Person("李四", "男", 36); // 实例化对象
        lisi.eat(); // 调用 lisi 对象的方法
        lisi.sleep();
    }
}

this

Person.java

public class Person {
    public Person t(){
        return this;
    }
}

Demo.java

public class Demo {
    public static void main(String[] args){
        Person zhangsan = new Person(); // 实例化对象
        Person lisi = new Person(); // 实例化对象

        System.out.println(zhangsan == zhangsan.t()); // true
        System.out.println(lisi == lisi.t()); // true
        System.out.println(zhangsan.t() == lisi.t()); // false
    }
}

总结：

this 是个指向，指向实例化后的对象。

static

可修饰类中属性或方法。

修改静态后由类直接拥有。

静态代码块

特性：

初始化类时，会自动执行。
只执行一次，不管你创建多少次。

语法：

static { 初始化一些静态数据 }

怎么才能执行：

创建对象
创建子类对象
访问静态属性
调用静态方法
主动加载：Class.forName("全限定名")

实例

public class Demo {
    public static void main(String[] args){
        Student.show(); // 访问静态方法
    }
}

class Student{
    String name;
    static int count; // 静态属性

    public static void show(){ // 静态方法
        System.out.println("学生人数: " + count);
    }

    static { // 静态代码块
        count = 50;
    }

}

abstract

可以修饰类，也可以修饰方法

修饰类

被 abstract 修饰的类称为抽象类。
抽象类意为不够完成，不够具体的类。
抽象类对象无法独立存在，即不能 new 对象。

何时定义抽象类？

我们拿动物来举例，有动物这个动物，我们所看见的都是动物的子类，而动物只是一个名词，并没有实际的载体。

这时我们可以将动物，改成抽象类。

修饰方法

被 abstract 修饰的方法称为抽象方法
类必须是抽象类，才可以创建抽象方法
继承抽象类的类，必须重写该抽象类所有抽象方法

实例

public class Demo {
    public static void main(String[] args){
        Animal dog = new Dog("旺财", 6);
        Animal bird = new Bird("八哥", 3);
        runDemo(dog);
        runDemo(bird);
    }
    // 多态, 父类作为参数
    public static void runDemo(Animal animal){
        animal.show();
        animal.eat();
    }
};

// 抽象类
abstract class Animal{
    String name;
    int age;
    public Animal(String name, int age){
        this.name = name;
        this.age = age;
    }
    // 抽象方法
    public abstract void eat();
    // 普通方法
    public void show(){
        System.out.println(this.name + "今年" + this.age + "岁了");
    }
}

class Dog extends Animal{
    public Dog(String name, int age){
        super(name, age);
    }
    // 必须重写eat, 因为父类eat是抽象方法
    @Override
    public void eat() {
        System.out.println("狗狗正在吃东西。。。");
    }
}

class Bird extends Animal{
    public Bird(String name, int age){
        super(name, age);
    }
    // 必须重写eat, 因为父类eat是抽象方法
    @Override
    public void eat() {
        System.out.println("鸟儿正在吃东西。。。");
    }
}

final

修饰类 ---> 不能被继承
修饰方法 ---> 不能被重写
修改变量 ---> 不能被修改 ---> 常量

instanceof

判断对象类型。

public class Demo {
    public static void main(String[] args){
        Object a = new A();
        System.out.println(a instanceof A); // true
        System.out.println(a instanceof B); // false
    }
}

class A{}
class B{}

访问修饰符

类的嵌套

一个类可以嵌套一个类，被嵌套的类我们称它为内部类。

内部类不可以声明：静态属性，静态方法。
但是可以声明：静态常量，静态最终方法。也就是 final 关键字。

快速使用

class Outer {
    String name = "__Outer__";
    int age = 1;

    class Inner{
        int age = 2;
        public void show(){
            System.out.println(name); // 没有重名, 可以简写。
            System.out.println(Outer.this.age); // 如果重名, 可以使用：外部类名 + this + 名。
            System.out.println(this.age); // 加 this 可以更好了理解。
        }
    }
}

class Test{
    public static void main(String[] args) {
        Outer outer = new Outer(); // 实例化外部类对象
        Outer.Inner inner = outer.new Inner(); // 实例化内部类独享
        inner.show(); // 内部类方法
    }
}

静态内部类

在内部类前加 static，正常类是不可以用 static。
用法与外部类相同。

class Outer {
    String name = "__Outer__";
    int age = 1;
    // 静态内部类
    static class Inner{
        int age = 2;
        public final void show(){
            // 因为是静态内部类, 想要使用外部类的一些属性和方法, 需要实例对象。它相当于一个外部类。
            Outer outer = new Outer();
            System.out.println(outer.name); // 访问外部类属性
            System.out.println(outer.age);
            System.out.println(this.age); // 访问内部类属性
        }
    }
}

class Test{
    public static void main(String[] args) {
        Outer.Inner inner = new Outer.Inner(); // 直接调用内部类
        inner.show(); // 内部类方法
    }
}

局部内部类

class Outer {
    String name = "__Outer__";
    public void show(){
        // 定义局部类
        class Inner{
            String name = "__Inner__";
            public void sayHi(){
                System.out.println(Outer.this.name); // 访问外部类属性
                System.out.println(this.name); // 访问局部类属性
            }
        }
        // 调用具备类
        Inner inner = new Inner();
        inner.sayHi();
    }
}

class Test{
    public static void main(String[] args) {
       Outer outer = new Outer();
       outer.show();
    }
}

匿名内部类

匿名内部类不是类的嵌套，而是定义了一个接口，不用使用implements去实现，用new的方式

public class HelloWorldAnonymousClasses {

    /**
     * 包含两个方法的HelloWorld接口
     */
    interface HelloWorld {
        public void greet();
        public void greetSomeone(String someone);
    }

    public void sayHello() {

        // 1、局部类EnglishGreeting实现了HelloWorld接口
        class EnglishGreeting implements HelloWorld {
            String name = "world";
            public void greet() {
                greetSomeone("world");
            }
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("Hello " + name);
            }
        }

        HelloWorld englishGreeting = new EnglishGreeting();

        // 2、匿名类实现HelloWorld接口
        HelloWorld frenchGreeting = new HelloWorld() {
            String name = "tout le monde";
            public void greet() {
                greetSomeone("tout le monde");
            }
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("Salut " + name);
            }
        };

        // 3、匿名类实现HelloWorld接口
        HelloWorld spanishGreeting = new HelloWorld() {
            String name = "mundo";
            public void greet() {
                greetSomeone("mundo");
            }
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("Hola, " + name);
            }
        };

        englishGreeting.greet();
        frenchGreeting.greetSomeone("Fred");
        spanishGreeting.greet();
    }

    public static void main(String... args) {
        HelloWorldAnonymousClasses myApp = new HelloWorldAnonymousClasses();
        myApp.sayHello();
    }
}

Lambda表达式

jdk1.8才出现Lambda表达式，只有函数式接口才可以使用Lambda表达式。可在接口上添加@FunctionalInterface，如果接口报错则不是函数式接口。

语法：()->{ }

当大括号 { } 内只有一条语句是可以去掉大括号

import java.io.IOException;

public class T {
    public static void main(String[] args) throws IOException {
        // 不使用Lambda表达式
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("线程1...");
            }
        };

        // 使用Lambda表达式
        Runnable r2 = ()->{
            System.out.println("线程2...");
        };

        // 使用Lambda表达式
        Runnable r3 = ()-> System.out.println("线程3...");
        
        // 运行
        new Thread(r1).start();
        new Thread(r2).start();
        new Thread(r3).start();
    }
}

posted @ 2020-11-12 08:09 Sun先生 Views(118) Comments(0) Edit 收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

Sun_先生

A man's station is limited only by his imagination
只有想不到，没有做不到。

Java 基础（二）

类的初始

快速使用

类的属性

类的方法

构造方法

方法重载

无限传参

实例化对象

快速使用

this

static

静态代码块

实例

abstract

修饰类

修饰方法

实例

final

instanceof

访问修饰符

类的嵌套

快速使用

静态内部类

局部内部类

匿名内部类

Lambda表达式

公告

Sun_先生

A man's station is limited only by his imagination 只有想不到，没有做不到。

Java 基础（二）

类的初始

快速使用

类的属性

类的方法

构造方法

方法重载

无限传参

实例化对象

快速使用

this

static

静态代码块

实例

abstract

修饰类

修饰方法

实例

final

instanceof

访问修饰符

类的嵌套

快速使用

静态内部类

局部内部类

匿名内部类

Lambda表达式

公告

A man's station is limited only by his imagination
只有想不到，没有做不到。