java 一个文件创建多个类 java怎么创建多个类

关键字：static的使用

1.static:静态的
2.static可以用来修饰：属性、方法、代码块、内部类

3.使用static修饰属性：静态变量
3.1 属性：按是否使用static修饰，又分为：静态属性 vs 非静态属性（实例变量）
  实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个属性中的非静态属性时，不会导致其他对象中相同的属性值的修改。
  静态变量：我们创建一个类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时是修改过的。
3.2 static修饰属性的其他说明。
  ① 静态变量随着类的加载而加载
  ② 静态变量的加载要早于对象的创建
  ③ 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中
3.3 静态属性举例：System.out;Math.PI

4.使用static修饰方法：静态方法
① 随着类的加载而加载，可以通过“类.方法”来调用
② 静态方法中，只能调用静态的方法或属性
非静态方法中，既可以调用非静态的方法和属性，也能调用静态的方法和属性

5.static注意点：
5.1 在静态的方法内，不能使用this关键字、super关键字
5.2 关于静态属性和静态方法的使用，大家都从生命周期的角度去理解

6.总结
开发中，如何确定一个属性是否要声明为static的？
 属性时可以被多个对象所共享的，不会随着对象的不用而不同的。
 类中的常量也常常声明为static

开发中，如何确定一个方法是否要声明为static的？
 操作静态属性的方法通常设置为static的
 工具类中的方法，习惯上声明为static的。比如，Math、Arrays、Collections

public class StaticTest {
    public static void main(String[] args){
        Chinese.nation = "中国";
        
        Chinese c1 = new Chinese();
        c1.name = "姚明";
        c1.age = 40;
        c1.nation = "CHN";

        Chinese c2 = new Chinese();
        c2.name = "马龙";
        c2.age = 30;
        c1.nation = "CHINA";
        System.out.println(c1.nation);
        Chinese.show();

    }
}

//中国人
class Chinese{
    String name;
    int age;
    static String nation;
    public static void show(){
        System.out.println("我是中国人");
    }
}

static关键字的应用

public class CircleTest2 {
    public static void main(String[] args){
        Circle2 c1 = new Circle2();
        Circle2 c2 = new Circle2();

        System.out.println("c1的id:" + c1.getId());
        System.out.println("c2的id:" + c2.getId());

        System.out.println("创建圆的个数为：" + Circle2.getTotal());
    }
}

class Circle2{
    private double radius;
    private int id;

    public Circle2(){
        id = init++;
        total++;
    }

    public Circle2(double radius){
        this();
        this.radius = radius;
    }

    private static int total;//记录创建圆的个数
    private static int init = 1001;//static声明的属性被所有对象所共用

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    public int getId() {
        return id;
    }

    public static int getTotal() {
        return total;
    }

    public double findArea(){
        return 3.14 * Math.pow(radius, 2);
    }
}

单例的设计模式

1.所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例

2.如何实现？
饿汉式 vs 懒汉式

3.区分饿汉式和懒汉式
饿汉式：坏处（对象加载时间过长）；好处（线程安全的）
懒汉式：好处（延迟对象的创建）；坏处（目前的写法线程不安全）—> 到多线程内容时，再修改

单例设计模式-应用场景

网站的计数器
应用程序的日志应用
数据库连接池
读取配置文件的类
Application
Task Manager（任务管理器）
Recycle Bin（回收站）

//方式一：饿汉式
public class SingletonTest1 {
    public static void main(String[] args){
        Bank bank1 = Bank.getInstance();
        Bank bank2 = Bank.getInstance();
        System.out.println(bank1 == bank2);
    }
}
class Bank{
    //1.私有化类的构造器
    private Bank(){

    }

    //2.内部创建类的对象
    private static Bank instance = new Bank();

    //3.提供公共的静态方法，返回类的对象
    public static Bank getInstance(){
        return instance;
    }
}

//懒汉式
public class SingletonTest2 {
    public static void main(String[] args){
        Order2 o1 = Order2.getInstance();
        Order2 o2 = Order2.getInstance();

        System.out.println(o1 == o2);
    }
}
class Order2{

    //1.私有化类的构造器
    private Order2(){

    }

    //2.声明当前类对象，没有初始化
    private static Order2 instance = null;

    //3.声明public、static的返回当前类对象的方法
    public static Order2 getInstance(){
        if(instance == null){
            instance = new Order2();
        }
        return instance;
    }
}

理解main方法的语法

main()方法的使用说明：
1.mian()方法作为程序的入口
2.main()方法也是一个普通的静态方法

public class MainTest{
    public static void main(String[] args){
        Main.main(new String[100]);
    }
    
}

class Main{
    public static void main(String[] args){
        for(int i = 0;i < args.length;i++){
            args[i] = "args_" + i;
            System.out.println(args[i]);
        }
    }
}

类的成员之四：代码块（或初始化块）

1.代码块的作用：用来初始化类、对象
2.代码块如果有修饰的话，只能使用static
3.分类：静态代码块 vs 非静态代码块
4.静态代码块
① 内部可以输出语句
② 随着类的加载而执行，只执行一次
③ 作用：初始化类的信息
④ 如果一个类中定义了多个代码块，则按照声明的先后顺序执行
⑤ 静态代码块的执行要优先于非静态代码块
⑥ 静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构

5.非静态代码块
① 内部可以输出语句
② 随着对象的创建而执行，每创建一个对象就执行一次非静态代码块
③ 作用：可以在类创建时，对对象的属性进行初始化
④ 如果一个类定义了多个非静态代码块，按照声明先后顺序执行
⑤ 非静态代码块内可以调用静态的属性、静态的方法或非静态的属性、非静态的方法

对属性可以赋值的位置：
① 默认初始化
② 显式初始化
③ 构造器中初始化
④ 有了对象以后通过“对象.属性”或“对象.方法”进行赋值
⑤ 在代码块中赋值

执行顺序：① - ② / ⑤ - ③ - ④

public class BlockTest{
    public static void main(String[] args){
        String desc = Persons.desc;
        Persons p1 = new Persons();

        System.out.println(p1.age);
    }
}
class Persons{
    //属性
    String name;
    int age;
    static String desc = "我是一个人";
    //构造器
    public Persons(){

    }

    public Persons(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //代码块
    {
        this.age = 1;
        System.out.println("hello,block");
        //调用非静态方法
        eat();
        //调用静态方法
        eat2();

    }

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

    //方法
    public void eat(){
        System.out.println("吃饭");
    }

    public static void eat2(){
        System.out.println("吃饭2");
    }

    public String toString(){
        return "Person [name = " + name + ", age = " + age + "]";
    }
}

关键字：final

1.final可以用来修饰的结构：类、方法、变量
2.final 用来修饰一个类：此类不能被其他类所继承
比如：String类、System类、StringBuffer类
3.final用来修饰方法：表明此方法不能被重写
比如：Object类中的getClass()方法
4.final用来修饰一个变量：此时的“变量”就成为是一个常量
4.1 final修饰属性，可以考虑赋值的位置有：显式初始化、代码块中初始化、构造器中初始化
4.2 final修饰局部变量：
尤其是使用final来修饰形参时，表明此形参时一个常量。当我们调用此方法，给常量形参赋一个实数。一旦赋值以后，就只能在方法体内使用此形参，但不能重新赋值。

static final 用来修饰属性：全局常量

抽象类与抽象方法

abstract关键字的使用

1.abstract：抽象的
2.abstract可以用来修饰的结构：类、方法
3.abstract修饰类：抽象类
此类不能实例化
抽象类中有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）
开发中，都会提供抽象类的子类，让子类对象实例化，完成相关操作

4.abstract修饰方法：抽象方法
抽象方法只有方法的声明，没有方法体
包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。
若子类重写了父类中的所有的抽象方法后，此子类可实例化
若子类没有重写父类中所有的抽象方法，此子类是抽象类

abstract使用上的注意点：
1.abstract不能用来修饰：属性、构造器等结构
2.abstract不能用来修饰私有方法、静态方法、final的方法final 的类

抽象类的匿名子类

public class AbstractTest {
    public  static void main(String[] args){
        //一旦Human类抽象了，就不能实例化
//        Human man1 = new Human();
//        man1.eat();

        //创建一个匿名子类对象
        Human man2 = new Human() {
            @Override
            public void eat() {
                System.out.println("人恰饭");
            }
        };
        man2.walk();


        //创建匿名子类的匿名对象
        method1(new Human() {
            @Override
            public void eat() {
                System.out.println("人恰饭");
            }
        });
    }
    public static void method1(Human man){
        man.eat();
        man.walk();
    }
}

abstract class Human{
    String name;
    int age;
    public Human(){

    }

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

    public abstract void eat();

    public void walk(){
        System.out.println("走路");
    }
}

class Student2 extends Human{
    public Student2(String name,int age){
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("恰饭");
    }
}

抽象类的应用：模板方法设计模式

public class TemplateTest {
    public static void main(String[] args){
        SubTemplate t = new SubTemplate();

        t.spendTime();
    }
}
abstract  class Template{
    //计算某段代码花费的时间
    public void spendTime(){
        long start = System.currentTimeMillis();

        code();//不确定的部分、易变的部分

        long end = System.currentTimeMillis();
        System.out.println("花费的时间为：" + (end - start));
    }

    public abstract void code();
}

class SubTemplate extends Template{

    @Override
    public void code() {
        int maxNum = 1000;
        int count = 0;
        label:for(int i = 2;i <= maxNum;i++){
            for(int j = 2;j <= Math.sqrt(i); j++){
                if(i % j == 0){
                    continue label;
                }
            }
            count++;
        }
        System.out.println(count);
    }
}

接口（interface）

接口的使用

1.接口使用interface来定义

2.Java中，接口和类是并列的两个结构

3.如何定义接口，定义接口中的成员
3.1 JDK7及以前：只能定义全局常量和抽象方法
全局常量：public static final的。但是书写时，可以省略不写。
抽象方法：public abstract的
3.2 JDK8及以后：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法（略）
  ① 接口中实现的静态方法，只能通过接口调用
  ② 通过实现类的对象，可以调用接口中的默认方法
如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写后的方法
  ③ 如果子类（或实现类）继承的父类和实现的接口中声明了同名同参数的方法，那么子类在没有重写此方法的情况下，默认调用的是父类中同名同参数的方法。—>类优先原则
  ④ 如果实现类实现了多个接口，而这对个接口中定义了同名同参数的默认方法，那么在实现类中没有重写此方法的情况下，报错。—>接口冲突
这就必须在实现类中重写此方法
  ⑤ 如何在子类（或实现类）的方法中调用父类、接口中被重写的方法
接口名.super.方法名();

4.接口中不能定义构造器！意味着接口不可以实例化

5.Java开发中，接口通过让类去实现（implements）的方式来使用。
如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化
如果实现类没有覆盖接口中所有抽象方法，则此实现类仍然是抽象类

6.Java类可以实现多个接口 —> 弥补了Java单继承性的局限性
格式：class AA extends BB implements CC,DD,EE…

7.接口与接口之间可以继承，而且可以多继承

8.接口的具体使用，体现多态性

9.接口，实际上可以看做一种规范

10.开发中，体会面向接口编程！

匿名实现类等和抽象类相似。

面试题：抽象类与接口有什么异同

public class InterfaceTest{
    public static void main(String[] args){
        System.out.println(Flyable.MAX_SPEED);
        System.out.println(Flyable.MIN_SPEED);

        Plane p1 = new Plane();
        p1.fly();
    }
}

interface Flyable{
    //全局常量
    public static final int MAX_SPEED = 7900;//第一宇宙速度
    int MIN_SPEED = 1;//省略了public static final

    //抽象方法
    public abstract void fly();
    //省略了public abstract
    void stop();
}

class Plane implements Flyable{

    @Override
    public void fly() {
        System.out.println("通过引擎起飞");
    }

    @Override
    public void stop() {
        System.out.println("驾驶员停止减速");
    }
}
abstract class Kite implements Flyable{
    @Override
    public void fly() {

    }
}
interface Attackable{
    void attack();
}

class Bullet extends Object implements Flyable,Attackable,CC{

    @Override
    public void fly() {

    }

    @Override
    public void stop() {

    }

    @Override
    public void attack() {

    }

    @Override
    public void method1() {

    }

    @Override
    public void method2() {

    }
}

interface AA{
    void method1();
}
interface BB{
    void method2();
}
interface CC extends AA,BB{

}

接口应用：代理模式

public class NetWorkTest {
    public static void main(String[] args){
        Server server = new Server();
        ProxyServer proxyServer = new ProxyServer(server);

        proxyServer.browse();
    }
}
interface NetWork{
    public void browse();
}

//被代理类
class Server implements NetWork{

    @Override
    public void browse() {
        System.out.println("真实的服务器访问网络");
    }
}
//代理类
class ProxyServer implements NetWork{
    private NetWork work;

    public  ProxyServer(NetWork work){
        this.work = work;
    }

    public void check(){
        System.out.println("联网之前的检查工作");
    }
    @Override
    public void browse() {
        check();
        work.browse();
    }
}

接口应用：工厂模式（了解）

类的内部成员之五：内部类

1.Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B就是外部类

2.内部类的分类：成员内部类（静态的、非静态的） vs 局部内部类（方法内、代码块内、构造器内）

3.成员内部类：
一方面，作为外部类的成员：
  调用外部类的结构
  可以被static修饰
  可以被四种不同的权限修饰

另一方面，作为一个类：
  类内可以定义属性、方法、构造器等
  可以被final修饰，表示此类不能被继承，不使用则可以被继承
  可以被abstract修饰

4.关注如下3个问题
4.1 如何实现实例化成员内部的对象
4.2 如何在成员内部类中区分调用外部类的结构
4.3 开发中，局部内部类的使用

//Dog是Person的静态成员内部类
//创建Dog实例（静态的成员内部类）
Person.Dog dog = new Person.Dog();
//Dog内调用Person的属性、方法
Person.this.属性/方法名

//Bird是Person的非静态成员内部类
Person p = new Person();
Person.Bird bird = p.new Bird();

注意点：在局部内部类的方法中，如果调用局部内部类所声明的方法中的局部变量，则要求此局部变量声明为final的。（JDK8以后可以省略）