跳至主要內容

Java基础知识（上）

cheniy2025/9/17大约 13 分钟JavaJava基础

第 1 章：认识Java

1. Java分类：

  • Java SE：Java核心类（面向对象，API，JVM...）
  • Java EE：Java SE和用于企业级应用的类
  • Java ME：Java SE中的一部分和消费类电子产品的软件开发

2. 常用概念：

  • JVM：Java虚拟机
  • JRE：Java运行环境
  • JDK：Java开发包包含JRE等
  • SDK：软件开发包的统称（JDK为其中一种）

3. 编译过程

  • 编译为字节码文件：javac hello.java
  • 运行字节码文件：java hello
  • 一个Java文件中有几个Class编译后就有几个*.class文件

4. classpath与path的作用

  • classpath：主要指的是类（*.class）的运行路径，Java命令执行时将运作该路径下的*.class文件
  • path：主要指的是操作系统可以执行命令的程序路径

第 2 章：简单的Java程序

1. 同时声明变量

int num,num1,num2;

第 3 章：Java基础程序设计

1. Java基本数据类型

2. Integer包装类

  • Integer是Java的包装类，可实现对数字的自动拆箱和装箱

3. &&普通和&以及||和|的区别

  • 短路&&（||）：只要其中一个条件为假（真）就不用判断后面的
  • 普通&（|）：全都判断

第 4 章：数组与方法

1. 数组定义

//方法一：静态定义
int arr[]={1,2,3,4,5,6,7}

//方法一：分配空间
int arr[]=new int[7]

2. 数组栈堆内存

3. 主方法使用同类中的方法

  • 原因：主方法是静态方法无法调用非静态方法
public class dome02 {
    public static void main(String[] args) {
        // 主方法使用同类方法
        printHello();
    }
    // 主方法使用同类方法===>需要在使用的方法上使用static 
    public static void printHello(){
        System.out.println("printHello...");
    }
}
  • 在自定义类中（无主方法中）无须static，因为此类中的方法需要实例化对象调用

第 5 章：面向对象编程（基础篇）

1. 实例化对象

  • 实例化对象堆栈：

2. 构造方法

  • 类中已经声明构造方法后，不再使用默认无参的构造方法

3. 匿名对象

  • 直接进行new 类（）实例化，不用赋值给变量，基本用于参数传递
  • 堆栈：只在堆里面开辟内存空间，栈中不引用
  • 回收：使用一次就等待回收

4. String类

  • 字符串就是一个String类匿名对象
String name="lihua"             // 匿名对象（直接赋值）
String name=new String("lihua") // new 实例化对象
  • 字符串用" "，字符用' '
  • 字符串比较要用equals（），“==”比较的是栈的地址
  • 字符串的内容不可改变，每次修改都会开辟一个堆空间
String共享设计模式

String采用的是共享设计模式：（面试：直接赋值和new实例化的区别？）

  • String采用直接赋值的时候，会将该字符串放入对象池中，下次直接赋值并且是相同的字符串时不会创建堆内存空间，直接引用内存池
  • 采用new进行对象实例化时：new了多少个就开辟多少个堆内容空间
  • 常用方法：

5. this关键词

  • this可以表示本类的属性和构造方法
  • this还可以表示调用该方法的对象
public class User {

    private String name;
    private Integer age;

   
    User(){
        //用法1：调用本类参数
        this.name="123";  
        this.age=18;
    }
   
    User(String otherName,Integer otherAge){
        // 用法2：调用本类构造方法
        this();
        this.name=otherName;
        this.age=otherAge;
    }
   
    // 比较对象
    public boolean compare(User p_user){
        // 用法3：表示调用的对象（user1.compare（user2））
        User user1=this;
        User user2=p_user;
        
        if(user1==user2) return true;
        else if(user1.age>user2.age) return true;
        else return false;
    }


}

6. static关键字

  • 所有该类的实例化对象共享
  • 可以有类名.xx直接调用
  • 定义类方法时的两种因数：
    • 本类没有普通属性，实例化没有意义
    • 本类无法直接进行对象实例化（抽象类）
  • 内存模型：

    Java中的内存区域：

7. 代码块

  • 普通代码块：方法中定义，可以起到分割结构的作用
public void getInt(){
    // 分割结构
    {
        int x=10;
        System.out.println("1. "+x);
    }
    // 可以重复定义
    int x=20;
    System.out.println("2. "+x);
}
  • 构造块：定义在类中，每次实例化对象时比构造方法先调用，可多次
  • 静态代码块：加有static关键字的代码块，
静态代码块示例
// 类中的所有代码块只有被实例化的时候被调用
// 顺序为 静态>普通>构造
public class User {
    private String name;
    private Integer age;
    {
        System.out.println("1.类中的普通代码块...");
    }
    static {
        System.out.println("0.类中的静态代码块...");
    }
    User(){
        System.out.println("2.构造方法...");
    }
}

public class dome02 {
    static {
        System.out.println("在主方法所在类的静态代码块....");
    }
    public static void main(String[] args) {
        {
            System.out.println("普通代码块...");
        }
        System.out.println("----------------------------------");
        new User();
    }
}

/* 运行结果：
在主方法所在类的静态代码块....
普通代码块...
----------------------------------
0.类中的静态代码块...
1.类中的普通代码块...
2.构造方法...
*/

8. 单例设计模式（构造方法私有化）

  • 编写类的时候将构造方法进行私有化（外部无法new对象）
  • 在内部进行new一个对象，并设置该对象为static和private
  • 通过static方法对外部开放获取
单例模式示例
public class User {
    // 类中创建单例对象
    private static User instance=new User();
    
    private String name;
    private Integer age;
    // 私有化构造方法
    private User(){
        System.out.println("私有化构造方法...");
    }
    // 对设置的对象外部开发
    public static User getUser(){
        return instance;
    }
}

public class dome02 {

    public static void main(String[] args) {
        // 常规方法报错
        // User user = new User();
    
        // 通过getUser获取User对象
        User user1 = User.getUser();
        User user2 = User.getUser();
        User user3 = User.getUser();
        // 获取的三个对象都是一样的
        System.out.println(user1);
        System.out.println(user2);
        System.out.println(user3);
    }

/*
私有化构造方法...
test.User@1b28cdfa
test.User@1b28cdfa
test.User@1b28cdfa
*/

}

9. 内部类

  • 内部类可以在任意位置定义（类中，方法中，代码块中...）

  • 内部类可以访问外部类的属性方法

  • 外部类访问内部类的属性方法如下：
    a. static定义内部类

    new 外部类.内部类.属性方法

    b. 实例化内部类

    外部类 out = new 外部类
外部类.内部类 in = out.new 内部类
in.属性方法

第 6 章：面向对象编程（高级篇）

1. 继承

  • 子类也叫派生类，父类也叫基类
  • 子类不能直接调用父类的私有方法，也只能使用getter，setter获取修改
  • 实例化子类时，先调用父类的构造方法，再调用子类的构造方法

2. 方法覆写

  • 子类覆写父类方法后，等于直接覆盖掉父类中的方法，此后无法通过子类再调用（子类强转成父类也不行）
  • 子类覆写父类方法时，权限不能比父类更严格
  • 修改方法的权限（父类private，子类public）不算覆写，等于子类重新定义了新的方法

3. final关键字

  • final的类不能有子类，
  • final的方法不能被覆写
  • final的常量不能被修改

4. 抽象类（abstract）

  • 含有抽象方法的类一定是抽象类
  • 抽象类必须被子类（如果不是抽象类）继承，并且覆写其中全部的抽象方法
  • 抽象类中也可定义普通属性，普通方法（不强制子类覆写）
  • 抽象方法不能使用private，否则子类无法访问覆写
  • 抽象类也是要构造方法的（子类实例化时也会执行）
  • 总结：抽象类也只是比普遍类多了个抽象方法，不能实例化之外和普通类相差无几

5. 接口

  • 一种特殊的类，里面全是全局常量（static final）和公共的抽象方法所组成的
  • 1.8版本后可以定义普通方法和静态方法
    • 普通方法必须用default修饰，所有实现该接口的类都自动继承且都相同
    • 静态方法用static修饰，可以不用类实现使用，可以直接调用 接口名.方法名 使用
  • 接口中的抽象方法必须为public，因为其特殊性可以简写
// 接口定义原型
public abstract interface A {
    public static final String name = "接口原型";
    public abstract void print();
}
// 接口简写
public interface A {
    String name = "接口简写";
    void print();
}
  • 接口也必须通过子类实现接口（implement）进行实例化，并且覆写其中全部方法
  • 接口之间可以实现多继承
public interface A extends B,C
// 子类同时实现A，B，C的方法

6. 对象的多态性

主要有两种形式：

  1. 向上转型：子类对象 => 父类对象
  2. 向下转型：父类对象 => 子类对象
代码格式：
向上：父类 父类对象 = 子类实例 
向下：子类 子类对象 = （子类）父类实例  // 需要验证（instanceof关键字）
  • 是否需要验证，可以根据子类实例化的过程判断（先创建父类后子类）
    • 故子类转父类不需要
    • 但父类转子类需要（父类不确定该子类是否为自己的子类）
  • 子类转成父类时：被子类覆写的方法无法还原
多态性示例
public class User {
    public void print() {
        System.out.println("User...");
    }
}

public class Student extends User {
    // 覆写
    public void print() {
        System.out.println("Student...");
    }
}

public class dome02 {
    public static void main(String[] args) {
        Student student = new Student();
        User user = (User) student;
        // 转换为User但print已经被覆写所有结果认为Student...
        user.print();
    }
}

/*运行结果：
Student...
*/
  • 两个类是否能继续转化的前提是具有 “父子关系”
    • 父子关系：通过子类实例化创建的父类
    • 非父子关系：通过子类实例化创建的父类，单独实例化的父类2，该子类和父类2就无父子关系

一般用于子类转为父类后，还需要转为子类，具体实例：P189

7. intanceof关键词

对象 instanceof 类 => 返回Boolean类型
/*
该对象是否为该类的实例
该对象是否可以转换为该类的实例化对象
*/

8. 抽象类和接口的补充

  • 抽象类和接口只有通过子类实例化，再通过子类转化为父类才能得到自身实例化
  • 抽象类实际应用：模版设计
  • 接口实际应用：制定标准

9. 工厂设计模式

  • 存在问题：一般在主方法中实例化子类时，如果要更换子类时就需要修改主方法！
  • 解决方法：引入一个过渡端，来创建子类，主方法调用，过渡端返回子类实例化

10. 代理设计模式

  • 代理模式：一个代理主题来操作真实主题，代理主题实现其他业务，真实主题实现真实业务
代理模式示例
// 真实主题
public class Real implements NetWork{
    public void browse() {
        System.out.println("上网浏览信息...");
    }
}
// 代理主题
public class Proxy implements NetWork{
    // 真实主题作为参数，通过传入Real真实主题（Real覆写过的父类）来获得需要进行的真实操作
    private NetWork netWork;
    Proxy(NetWork netWork){
        this.netWork=netWork;
    }
    // 需要代理操作的其他处理方法
    public void check(){
        System.out.println("检查上网环境...");
    }
    // 通过调用顺序实现先处理代理主题，再实现真实主题
    public void browse() {
        check();
        netWork.browse();
    }
}

public class dome02 {
    public static void main(String[] args) {
        Proxy proxy = new Proxy(new Real());
        proxy.browse();
    }
}

/*检查上网环境...
上网浏览信息...*/

11. 适配器设计模式

  • 存在问题：当一个接口中的方法过多，一个类要实现该接口，但用不到这么多方法也要全部实现？
  • 解决方法：引入一个抽象类来对接口进行空实现，然后上述类来继承该抽象类，选择性覆写方法
适配器模式示例
// 接口
public interface A {
    // 定义6个方法
    void getAAA();
    void getBBB();
    void getCCC();
    void getDDD();
    void getEEE();
    void getFFF();
}

// 抽象类（适配器）实现接口
public abstract class Adapter implements A {
    // 对接口中所有方法进行空实现
    public void getAAA() {}
    public void getBBB() {}
    public void getCCC() {}
    public void getDDD() {}
    public void getEEE() {}
    public void getFFF() {}
}
// 所需类继承适配器
public class User extends Adapter{
    // 自行选择需要实现的方法
    public void getAAA() {
        System.out.println("AAA...");
    }
    public void getCCC() {
        System.out.println("CCC...");
    }
}

public class dome02 {
    public static void main(String[] args) {
        System.out.println("子类对象--------------");
        User user = new User();
        user.getAAA();
        user.getCCC();
        System.out.println("接口对象--------------");
        A a=user;
        a.getAAA();
        a.getCCC();
    }
}

/*
子类对象--------------
AAA...
CCC...
接口对象--------------
AAA...
CCC...
*/

12. 内部接口\内部抽象类

  • 一个接口中可以定义一个或多个接口或抽象类
  • 一个抽象类中也可以定义一个或多个接口或抽象类
  • 具体实现：P199

13. Object类

  • 利用Object类可以实现参数的统一
  • 所有类都是Object类的子类，都有Object中的方法
  • 主要Object方法有：

    其中 toString（）和 equals（）方法默认输出和比较地址，一般需要覆写

14. 包装类

  • 引用数据类型可以使用Object进行数据类型的统一
  • 存在问题：数据分为引用数据和基本数据，基本数据类型并不是类无对象，不符合Java中一切皆对象原则
  • 解决方法：将每个基本数据类型都对应一个包装类（这样这些数据就可以使用一些类方法：数字转字符串等）

15. 自动拆箱装箱

  • 拆箱装箱
int x=10;
// 装箱
Integer i=new Integer(x);
// 拆箱
int y=i.intValue();
  • 自动拆箱装箱
// 装箱
Integer i=10;
// 拆箱
int y=i;
System.out.println(y);

16. 匿名内部类

  • 匿名内部类是在接口和抽象类的应用上发展起来的
  • 如果接口的实现类只需要使用一次，就可以写成匿名内部类
匿名内部类示例
public interface A {
    void print();
}

public  class X  {
    // 按原来思路应该实例化A接口（实现类实现），调用fun（写入实例化实现类）
    // 具体：添加一个实现类B类实现A接口，然后调用fun时参数为new B（）
    public void fun(A a){
        a.print();
    }

    // 现在只需要需要参数的地方使用匿名内部类
    public void print() {
        // 匿名内部类
        this.fun(new A() { // 这个匿名内部类代替了new B()，就不用新建类B了
            @Override
            public void print() {
                System.out.println("匿名内部类...");
            }
        });
    }

}
最近更新
贡献者: cheniy