Java基础知识

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基础知识

​ 注: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)自动类型转换(类比小瓶中的水装入大瓶中)

Java基础知识

​ (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();
	}

}
上一篇:原型和原型链


下一篇:继承多态