Java基础知识

第一章 Java概述

1、java中的常用类：

​ （1）java.util:包含Java中大量工具类、集合类，例如，Arrays,List,Set等。

​ （2）java.net:包含java网络编程相关接口和类。

​ （3）java.io:输入、输出相关的类和接口。

​ （4）java.awt:包含用于构建图形界面（GUI）的相关类和接口。

​ （5）java.sql:数据库编程

2、java的三个技术平台

​ （1）Java SE（平台标准版）:开发普通桌面和商务应用程序，包括了最核心的类库，如集合、IO、数据库连接以及网络编程；

​ （2）Java EE（平台企业版）:开发装配企业级应用，主要包括Servlet,JSP,JavaBean,EJB,Web Service等；

​ （3）Java ME（平台微型版）:开发电子消费产品和嵌入式设备。

3、JDK的使用

​ JDK:Java开发环境，包括java编译器、java运行工具、java文档生成工具、java打包工具等。

4、配置PATH环境变量

​ （1）打开环境变量窗口，右击桌面上的【计算机】图标，从下拉菜单中选择【属性】，在出现的【系统】窗口中选择【高级系统设置】，然后在【高级】窗口中单击【环境变量】按钮，打开【环境变量】对话框。

​ （2）配置JAVA_HOME变量。单击【系统变量】列表框中的【新建】按钮，弹出【新建系统变量】对话框，将【变量名】的文本区域值设置为JAVA_HOME，【变量值】的文本区域值设置为JDK的安装目录，添加完成后，单击窗口的【确定】按钮，即完成JAVA_HOME的配置。

​ （3）配置PATH变量。在【环境变量】对话框中的【系统变量】列表框中选中名为Path的系统变量，单击【编辑】按钮，打开【编辑系统变量】对话框，并在变量值的文本区域值的起始位置添加"%JAVA_HOME%\bin;".单击【确定】即完成环境变量配置。

第二章 Java编程基础

1、Java中的标识符

​ 标识符可以有任意顺序的大小写字母、数字、下划线、美元符号组成，但不能以数字开头

eg:

		username; √
		username123; √
		username_123;  √
		_username;  √
		123username;  ×
		class;   ×
		Hello World;  ×

2、Java中的变量与常量

​ （1）变量的定义：

变量类型 变量名 [=初始值]
int x = 0,y;
y = x + 3;

​ (2) 变量的数据类型：

​ 注：java中小数会被默认为double型，因此为float类型变量赋值时，其后一定要加上f(F)，而double型可加d(D)或不加均可。

eg:

float f =100;
float f1 = 123.4f;   //必须加f(F)
double d = 100;
double d1 = 12.3;
char c = 'a';
char ch = 97;
boolean flag = false;
flag = true;

（1）Java中的类型转换

​ （1）自动类型转换（类比小瓶中的水装入大瓶中）

​ （2）强制类型转换

目标类型 变量名 = （目标类型）值;
int num = 4;
byte b = (byte) num;

​ （3）表达式类型自动提升

​ 表达式数据类型自动提升，如byte,short,char类型的变量在运算期间类型会自动提升为int，然后再进行计算。

		byte b = 3;
		short s = 4;
		char c = 5;
		//byte b1 = b+s+c;
		byte b2 = (byte)(b+s+c);
		System.out.println("b2="+b2);

3、Java中数组的声明

​ (1)一维数组

数组类型[] 数组名 = new 数组类型[数组长度];
数组类型[] 数组名 = new 数组类型[]{数组元素0，数组元素1，....};
数组类型[] 数组名 = {数组元素0，数组元素1，...};
int[] ids = new int[100];
String[] names = new String[]{"张三","李四"};
Object[] object = {"张三","tom",..};

​ (2)二维数组

int[][] arr = new int[3][4];
int[][] arr = new int[3][];  //只指定二维数组的长度，不确定每个数组的元素个数
//直接使用嵌套大括号对数组初始化赋值
int[][] arr = {{1,2},{1,2,3},{1,2,3,4}};

第三章 面向对象

1、方法的重载和递归

（1）方法重载

多个名称相同，但是参数类型或者参数个数不同的方法；

注意：方法重载与返回值类型无关——

package com.itcast;

public class Example06 {
	//1.实现两个整数相加
	public static int add(int x,int y) {
		return x+y;
	}
	//2.实现三个整数相加
	public static int add(int x,int y,int z) {
		return x+y+z;
	}
	//3.实现两个小数相加
	public static float add(float x,float y) {
		return x+y;
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int sum1 = add(1,2);
		int sum2 = add(1,2,3);
		float sum3 = add(1,2);
		System.out.println("sum1="+sum1);
		System.out.println("sum2="+sum2);
		System.out.println("sum3="+sum3);
		
	}

}

2、构造方法

​ 方法名与类名相同；在方法名前没有返回值类型的声明；在方法中不能使用return语句返回一个值，但可以单独写return语句来作为语句的结束。

[修饰符] 方法名([参数列表]){
	//方法体
}
this关键字的用法
1、通过this调用成员变量，解决与局部成员变量重名问题
class Person{
	int age;
	public Person(int age){
		this.age = age;
	}
}
2、通过this调用成员方法
Class Person{
	public void openMouse(){
		//
	}
	public void speak(){
		this.openMouse();
	}
}
3、通过this调用构造方法
class Person{
	public Person(){
		System.out.println("无参的构造方法被调用了");
	}
	public Person(int age){
		this();
		System.out.println("有参的构造方法被调用了");
	}
}
public class Example11{
	public static void main(String[] args){
		Person p = new Person(18);
	}
}

3、this关键字的注意事项

一、只能在构造方法中使用this调用其他的构造方法，不能再成员方法中使用。

二、在构造方法中，使用this调用构造方法的语句必须是该方法的第一条执行语句，且只能出现一次。

三、不能在一个类的两个构造方法中使用this相互调用。

4、static 关键字

（1）静态变量

​ 某些特定的数据在内存中只有一份，能够被一个类中所有的实例对象所共享。注意：static关键字只能用于修饰成员变量，不能修饰局部变量。

类名.变量名
package com.itcast;
class Student{
	static String schoolName;
}
public class Example12 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Student stu1 = new Student();
		Student stu2 = new Student();
		Student.schoolName = "清华大学";  //为静态变量赋值
		System.out.println("我是"+stu1.schoolName+"的学生1");
		System.out.println("我是"+stu2.schoolName+"的学生2");		
	}

}

（2）静态方法

类名.方法名   或者    实例对象名.方法
class Person{
	public static void say(){
		System.out.println("hello!");
	}
}
public class Example13{
	public static void main(String[] args){
		Person.say();
		Person p = new Person();
		p.say();
	}
}

（3）静态代码块

sattic{
	//多行代码
}
类被加载时，静态代码块只执行一次，通常用来对成员变量进行初始化。（使用时才被加载）

第四章 面向对象下

1、类的继承

​ 类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有的类成为父类或基类，子类自动拥有父类可继承的所有方法和属性。

[修饰符] class 子类名 extends 父类名{
	//程序核心代码
}

注意：1、类只支持单继承，即一个类只能有一个直接父类；

​ 2、多个类可以继承同一个父类；

​ 3、一个父类可以再去继承另外的父类。

2、重写父类方法

条件：重写的方法和父类被重写的方法有相同的方法名、参数列表、返回值类型。

注意：子类重写时，不能使用比父类中被重写的方法更严格的访问权限。

3、super关键字

​ 作用：为了解决子类重写父类方法后，子类对象将无法直接访问父类被重写的方法。可用来访问父类的成员变量、成员方法、构造方法。

（1）使用super调用父类成员变量和成员方法

super.成员变量
super.成员方法([参数1,参数2...])
package com.exten;

//定义animal类
class Animal{
	String name = "动物";
	//定义动物叫的方法
	void shout() {
		System.out.println("动物发出叫声");
	}
}

//定义dog类继承animal类
class Dog extends Animal{
	String name = "犬类";
	//重写父类的shout方法
	void shout() {
		super.shout();
	}
	//定义一个打印name的方法
	public void printName() {
		System.out.println("name="+name);
	}
}
//测试类
public class Example01 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Dog dog = new Dog();
		
		dog.printName();
		dog.shout();
	}

}

（2）使用super关键字调用父类的构造方法

super([参数1,参数2...])
package com.exten;

//定义animal类
class Animal{
	//定义animal的构造方法
	public Animal(String name) {
		System.out.println("我是一只"+name);
	}
}

class Dog extends Animal{
	public Dog() {
		super("沙皮狗");   //调用父类有参的构造方法
	}
}
//测试类
public class Example01 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Dog dog = new Dog();
	}

}

注意：通过super调用父类构造方法的代码必须位于子类构造方法的第一行，并且只能出现一次。

4、final关键字

​ final可修饰类、变量、和方法。被final修饰的具有以下方法：

（1）final修饰的类不可继承；

（2）final修饰的方法不能被子类重写；

（3）final修饰的变量（成员变量和局部变量）是常量，只能被赋值一次；

//final修饰方法
package com.exten;
//定义animal类
class Animal{
	//使用final关键字修饰shout方法
	public final void shout() {
		
	}
}
//定义Dog类继承Animal类
class Dog extends Animal{
	//重写Animal的shout方法
	public void shout() { //此处会报错
		
	}
}
//测试类
public class Example01 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Dog dog = new Dog();
	}
}
//final修饰变量
public class Example11{
	//final修饰的成员变量，必须在声明的同时进行赋值，否则编译报错
    final intm;
    public static void main(String[] args) {
		// final修饰的局部变量，可以先声明，在进行一次赋值
		final int n;
        n = 4;
	} 
}

5、抽象类和接口

（1）抽象类

​ 抽象方法必须使用abstract修饰，并且在定义该方法是不需要实现方法体。当一个类中包含了抽象方法，那么该类也必须使用abstract修饰，即为抽象类，但抽象类中不一定只有抽象方法，含有抽象方法的类必为抽象类。

//定义抽象类
[修饰符] abstract class 类名{
	//定义抽象方法
	[修饰符] abstract 方法返回值类型 方法名([参数列表]);
	//其他方法或属性
}
package com.exten;

//定义抽象animal类
abstract class Animal{
	//使用final关键字修饰shout方法
	public abstract void shout();
}
//定义Dog类继承Animal类
class Dog extends Animal{
	//实现抽象Animal的shout方法
	public void shout() {
		System.out.println("汪汪");
	}
}
//测试类
public class Example01 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Dog dog = new Dog();
		dog.shout();
	}

}

（2）接口

​ 一个抽象类中所有的方法都是抽象方法，就为接口，接口中除了抽象方法外，还可以有默认方法（default修饰）和静态方法（static修饰）

[修饰符] interface 接口名 [extends 父接口1，父接口2....]{
	[public][abstract][final] 常量类型 常量名 = 常量值;
	[public][abstract] 方法返回值类型 方法名 ([参数列表]);
	[public] default 方法返回值类型 方法名([参数列表]){
		//默认方法的方法体
	}
	[public] static 方法返回值类型 方法名([参数列表]){
		//类方法的方法体
	}
}

定义接口的实现类(必须实现接口中所有的抽象方法)

[修饰符] class 类名 [extends 父类名] [implements 接口1,接口2...]{
	...
}

6、多态

​ 多态是指不同类在调用同一个方法时所呈现出的多种不同的行为。

必要条件：继承、重写、父类引用指向子类对象

package com.exten;

//定义抽象animal类
abstract class Animal{
	//使用final关键字修饰shout方法
	public abstract void shout();
}
//定义Dog类继承Animal类
class Dog extends Animal{
	//实现抽象Animal的shout方法
	public void shout() {
		System.out.println("汪汪");
	}
}
//定义Cat类继承Animal类
class Cat extends Animal{
	//实现抽象Animal的shout方法
	public void shout() {
		System.out.println("喵喵");
	}
}
//测试类
public class Example01 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Animal an1 = new Dog();
		Animal an2 = new Cat();
		an1.shout();
		an2.shout();
	}

}