javase/java web技术要点

绥阳朱韬

已于 2022-10-17 12:05:27 修改

阅读量849

点赞数

文章标签： java

于 2022-10-13 14:38:33 首次发布

本文链接：https://blog.csdn.net/m0_62925279/article/details/127295614

版权

public static void main (String[] args) 详解

public static void main (String[] args) 是Java程序的入口方法，JVM在运行程序时，会先查找 main() 方法。

public 是权限修饰符，表明任何类或对象都可以访问这个方法。
static 表明mian()方法是一个静态方法，即方法中的代码是存储在静态存储区的，只要类被加载后，就可以使用该方法而不需要通过实例化对象来访问，可以直接通过类名.main() 直接访问。
void 表明方法没有返回值。
main 是JVM识别的特殊方法名，是程序的入口方法。
字符串数组参数args 为开发人员在命令行状态下与程序交互提供了一种手段。

引申：

（1）main() 方法是否还有其他可用的定义格式？

static public void main (String[] args) —— public 和 static 没有先后顺序
public static final void main (String[] args) —— 可以定义为final
public static synchronized void main (String[] args) —— 可以上同步锁
不管用哪种定义方式，都必须保证 main() 方法的返回值为 void，并有 static 和 public 关键字修饰。同时由于 main() 方法为程序的入口方法，因此不能用 abstract 关键字来修饰。

（2）同一个 .java 文件中是否可以有多个 main() 方法？

虽然每个类中都可以定义 main() 方法，但是只有与文件名相同的用 public 修饰的类中的 main() 方法才能作为整个程序的入口方法。

class T {
   public static void main (String[] args) {
   System.out.println("T main");
}
}

// 必须是用 public 修饰，且类名与文件名相同的类中的 main() 方法才是入口。
public class Test {
   public static void main (String[] args) {
   System.out.println("Test main");
}
}
程序运行结果为：

Test main

方法：

Java的方法类似于其它语言的函数，是一段用来完成特定功能的代码片段

public class Demo {

float a;
//实例方法
void sum(float num1,float num2){
a = Max(num1,num2);
}

//类方法
static float Max(float num1,float num2){
//取最大值
return num1 <= num2 ? num2 :num1;
}

public static void main(String[] args) {
Demo demo =new Demo();
demo.sum(22,33); //实例方法必需先初始化类的实例，然后通过类的实例才能调用
Demo.Max(12,9); // 类方法可以直接通过类名调用

}

一个类中的方法可以互相调用。但要注意：实例方法可以调用该类中的其他方法，例如，sum()可以调用Max()。类方法只能调用其他类方法，不能调用实例方法。
类方法又叫静态方法，实例方法又叫非静态方法。
类方法可以直接通过类名调用，实例方法必需先初始化类的实例，然后通过类的实例才能调用

JAVA中的父类与子类

在java中，一个父类可以有多个子类，但是子类只能有一个父类。子类通常通过关键字extends来继承父类。

public class Animal {
int a = 3;
AnimalClass() {
System.out.println("父类无参构造函数")；
}

AnimalClass(int i) {
System.out.println("有一个形参i");
}
AnimalClass(int i,int j){
System.out.println("有两个形参i，j");
}
}
class DogClass extends AnimalClass {
int a;
int b;
public DogClass() {
System.out.println("123一起上");
}
public class DogClass(int a) {
this a = a;
System.out.println("456一起上");
}
public AnimalClass() {
super.(3,4);
}
public show() {
System.out.println("show 好!");
}
public static void main(String[] args) {
DogClass sc1 = new Dogclass ();
AnimalClass sc2 = new Animalclass ();
AnimalClass sc3 = new Animalclass (3,4);
}
}
这就是一个简单的父类与子类

implements:

extends 是继承父类，只要那个类不是声明final或者定义为abstract就能继承,Java中不支持多重继承，继承只能继承一个类，但implements可以实现多个接口，用逗号分开就行了。

class A extends B implements C,D,E(){ //class子类名extends父类名implements接口名

}
覆盖：

一、Java中的方法覆盖
1.方法覆盖又称为方法重写，英语单词：override/overwrite
2.使用：
当父类中的方法已经无法满足当前子类的业务需求，子类有必要将父类中继承过来的方法进行重新编写，这个重新编写的过程称为方法的重写/覆盖
3.满足的条件：

方法的重写发生在具有继承关系的父子类之间
方法名相同返回值类型相同，返回值列表相同（尽量复制粘贴）
访问权限不能更低，可以更高
抛出异常可以更多，可以更少。
4.注意：

私有方法不能继承，所以不能覆盖。
构造方法不能继承，所以不能覆盖。
静态方法不存在覆盖。
覆盖只针对方法，不谈属性。

public class OverrideTest {
   public static void main(String[] args) {
       Animal a=new Animal();
       a.move();
       Cat bCat=new Cat();
       bCat.move();
       Bird bird=new Bird();
       bird.move();
   }
}

public class Animal {
   public void move() {
       System.out.println("动物在移动");

   }
}

public class Cat extends Animal{
   public void move() {
       System.out.println("猫在走猫步");

   }
}

public class Bird extends Animal{
   public void move() {
       System.out.println("鸟儿在飞翔");

   }
}

java中覆盖和重载的区别

1. 首先搞明白覆盖是什么？

· 举个栗子

public class Main {
   public static void main(String[] args) {
       new Father().print();
       new Son().print();
   }
}

class Father{
   public void print(){
       System.out.println("father");
   }
}
class Son extends Father{
   @Override
   public void print() {
       System.out.println("SON");
   }
}

2.重载是什么？

· 举个栗子

public class Main {
   public static void main(String[] args) {
       new Test().print();
       new Test().print(3);
       new Test().print(3,"双参");
   }
}

class Test{
   public void print(){
       System.out.println("无参");
   }
   public void print(int i){
       System.out.println(i+" "+"单参");
   }
   public void print(int i,String j){
       System.out.println(i+" "+j);
   }
}

该例子里写了多个print方法，但参数不同，因此可以运行，这也就是重载的含义，一个类中可以有多个同名不同参（参数列表不同）的方法。

final用法：

final关键字代表最终、不可改变的。
常见四种用法：
1. 可以用来修饰一个类
2. 可以用来修饰一个方法
3. 还可以用来修饰一个局部变量
4. 还可以用来修饰一个成员变量

接口：

接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组成。接口是解决Java无法使用多继承的一种手段，但是接口在实际中更多的作用是制定标准的。或者我们可以直接把接口理解为100%的抽象类，既接口中的方法必须全部是抽象方法

为什么要用接口
接口被用来描述一种抽象。
因为Java不像C++一样支持多继承，所以Java可以通过实现接口来弥补这个局限。
接口也被用来实现解耦。
接口被用来实现抽象，而抽象类也被用来实现抽象，为什么一定要用接口呢？接口和抽象类之间又有什么区别呢？原因是抽象类内部可能包含非final的变量，但是在接口中存在的变量一定是final，public,static的。
接口语法：

java类前使用 private static 类名对象 = new 类名() 的作用。

举例：这里有一个DButils工具类，专门用来对数据库进行增，删，改，查“”操作。

public class DButils {
public void add() {
System.out.println("对数据库进行add操作");
}

public void update() {
System.out.println("对数据库进行update操作");
}

public void query() {
System.out.println("对数据库进行query操作");
}

public void delete() {
System.out.println("对数据库进行delete操作");
}
}

现在，在Service类中对DButils中的方法进行调用，

public class Service {
private DButils utils = new DButils();

public void methodA() {
utils.add();
utils.query();
}

public void methodB() {
utils.update();
utils.add();
}

public void methodC() {
utils.delete();
utils.add();
}
}

可以看出，在Service类中只创建了一个DButils对象，但却可以在下方的methodA,methodB,methodC方法中进行重多次的调用。

好处：
1、多次调用DButils中的方法，但只需要创建一次对象，因此，大大节省了创建对象所需的内存空间，并且方便调用【在开发中经常使用】
2、private表示私有，在同一类内可见, 因此在其他类中无法直接对该对象进行修改，保证了对象的安全性。

类：

package NeiBuLei;
public class OuterClass {
//成员变量
private String OuterName;
//成员方法
public void display(){
System.out.println("这是外部类方法！");
System.out.println(OuterName);
}
//内部类
public class InnerClass{
//成员变量
private String InnerNme;
//构造方法
public InnerClass() {
InnerNme = "Inner Class";
}
//成员方法
public void display(){
System.out.println("这是内部类方法！");
System.out.println(InnerNme);
}
}
// 主方法
public static void main(String[] args) {
OuterClass outerClass = new OuterClass();
outerClass.display();//这是外部类方法！null

// 这个类是内部类，已经不是独立的类了，因此不能像外部类一样直接创建！
//InnerClass innerClass = new InnerClass(); 行不通
OuterClass.InnerClass innerClass = outerClass.new InnerClass();// 同成员方法/变量只是加了个前缀
innerClass.display();// 这是内部类方法！
}
}
反射

//1、通过对象调用 getClass() 方法来获取,通常应用在：比如你传过来一个 Object
// 类型的对象，而我不知道你具体是什么类，用这种方法
　　Person p1 = new Person();
　　Class c1 = p1.getClass();

//2、直接通过类名.class 的方式得到,该方法最为安全可靠，程序性能更高
// 这说明任何一个类都有一个隐含的静态成员变量 class
　　Class c2 = Person.class;

//3、通过 Class 对象的 forName() 静态方法来获取，用的最多，
// 但可能抛出 ClassNotFoundException 异常
　　Class c3 = Class.forName("com.ys.reflex.Person");

list方法和数组相比，list是动态的

map:

以键值对形式来保存数据 ---key ---value；

键(key)值(value)来保存数据，其中值(value)可以重复，但键(key)必须是唯一，相同就覆盖；

也可以为空，但最多只能有一个key为空；

它的主要实现类有HashMap(去重)、LinkedHashMap、TreeMap(排序)。指的都是对key 的操作；

HashSet去重和HashMap的关系：

HashSet依赖Map 存储数据，set在保存数据时，实际上是在向Map中key这一列中存数据；

2、Map通用方法
put(key,value)：存入Map中的一个key-value键值对映射；

get(key)：返回指定key所映射的值；

int size()：返回键值对的数量；

remove(key)：删除指定key的一对映射；

containsKey(key)：判断是否包含指定的key；
package com.zb.study.map;

import java.util.HashMap;
import java.util.Map;

//测试HashMap
public class TestHashMap {
public static void main(String[] args) {
//创建HashMap
Map<String,String> map = new HashMap<>();
//存放元素
map.put("齐天大圣","孙悟空");
//取出元素
String s = map.get("齐天大圣");
System.out.println(s);
//获取map长度
int size = map.size();
System.out.println(size);
//判断是否包含指定key
boolean b = map.containsKey("齐天大圣");
System.out.println(b);
}
}

Super

super 可以用来直接调用父类中的构造方法

public class Person {
public Person(String name, int age) {
}
public Person(String name, int age, String sex) {
}
}

public class Student extends Person {
public Student(String name, int age, String birth) {
super(name, age); // 调用父类中含有2个参数的构造方法
}
public Student(String name, int age, String sex, String birth) {
super(name, age, sex); // 调用父类中含有3个参数的构造方法
}
}

super和this的区别

this 指的是当前对象的引用，super 是当前对象的父对象的引用。下面先简单介绍一下 super 和 this 关键字的用法。

super 关键字的用法：

super.父类属性名：调用父类中的属性
super.父类方法名：调用父类中的方法
super()：调用父类的无参构造方法
super(参数)：调用父类的有参构造方法

如果构造方法的第一行代码不是 this() 和 super()，则系统会默认添加 super()。

this 关键字的用法：

this.属性名：表示当前对象的属性
this.方法名(参数)：表示调用当前对象的方法

当局部变量和成员变量发生冲突时，使用this.进行区分。

java Iterator（迭代器）

要访问顺序容器和关联容器中的元素，需要通过“迭代器（iterator）”进行。迭代器是一个变量，相当于容器和操纵容器的算法之间的中介。迭代器可以指向容器中的某个元素，通过迭代器就可以读写它指向的元素。从这一点上看，迭代器和指针类似。

Java Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法

调用 it.next() 会返回迭代器的下一个元素，并且更新迭代器的状态。

调用 it.hasNext() 用于检测集合中是否还有元素。

调用 it.remove() 将迭代器返回的元素删除。

Iterator 类位于 java.util 包中，使用前需要引入它，语法格式如下：

import java.util.Iterator; // 引入 Iterator 类

// 获取迭代器
Iterator<String> it = sites.iterator();

集合：

3.常用集合的分类：
Collection 接口的接口对象的集合（单列集合）
├——-List 接口：元素按进入先后有序保存，可重复
│—————-├ LinkedList 接口实现类，链表，插入删除，没有同步，线程不安全
│—————-├ ArrayList 接口实现类，数组，随机访问，没有同步，线程不安全
│—————-└ Vector 接口实现类数组，同步，线程安全
│ ———————-└ Stack 是Vector类的实现类
└——-Set 接口：仅接收一次，不可重复，并做内部排序
├—————-└HashSet 使用hash表（数组）存储元素
│————————└ LinkedHashSet 链表维护元素的插入次序
└ —————-TreeSet 底层实现为二叉树，元素排好序

Map 接口键值对的集合（双列集合）
├———Hashtable 接口实现类，同步，线程安全
├———HashMap 接口实现类，没有同步，线程不安全-
│—————–├ LinkedHashMap 双向链表和哈希表实现
│—————–└ WeakHashMap
├ ——–TreeMap 红黑树对所有的key进行排序
└———IdentifyHashMap
————————————————
这里写图片描述