Java教程

Java入门基础知识笔记

本文主要是介绍Java入门基础知识笔记,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

包含关系、继承关系、类与对象

例如:
包含关系:班级 学生 (has a relationship)
继承关系:学生 大学生 (is a relationship)
类与对象:大学 清华大学

重载

方法的重载:在同一个类中同一个名字表示不同的方法

  • 方法名必须相同(同一类中定义的同名方法)
  • 方法的参数必须不同(形参的个数、类型、顺序中至少一种不同)
  • 返回的类型可以不同

构造方法(构造函数)

构造方法:创建对象时被调用

类名 对象引用名 = new 构造方法();
Employee emp =new Employee();

  • tips:
    ①名字必须为类的名字(与类同名)
    ② 没有返回类型说明
    ③ 定义类中,无定义任何构造方法时,系统为该类自动定义一个隐含的构造方法,但没内容。不过一旦用户定义了构造方法,隐含构造方法失效

封装

信息隐藏,用类进行封装

  • 对内:结构完整,可自我管理,自我平衡,高度集中
  • 对外:功能明确,接口单一,各种环境独立工作

继承

继承:子类继承父类非私有的方法和属性,即新类必须在已有类的基础上进行构造。
java为单根继承,父类只有一个
java中每个类都有父类:Object

1.父类定义了自己的构造方法,子类所有的构造方法中都必须先调用父类,并且super(…)调用的语句必须是子类构造方法中的第一个

  • 父类Employee定义
public class Employee {
	String name;
	int age;
	float salary;
	Employee(String n,int a,float s){//构造函数
		this.name=n;
		this.age=a;
		this.salary=s;
	}
}
  • 子类Manager继承父类
public class Manager extends Employee {
	float allowance;
	Manager(String n, int a, float s,float allowance) {//构造函数
		super(n, a, s);//super表示当前对象的父类对象,表示父类的构造函数
		this.allowance=allowance;//this,表示当前对象
	}
}

2.覆盖(override):子类对父类同名方法的重写(子类可以把从父类那继承来的某个方法改写,形成与父类方法同名,解决问题相似,但具体实现和功能不一致的新方法

  • tips:
    ①覆盖满足条件:
  • 完全相同的方法名
  • 完全相同的参数列表
  • 完全相同类型的返回值
    ②调用父类被覆盖的方法:super.方法名

依旧以Employee和Manager为例:

public class Employee {
    //属性
	String name;
	int age;
	float salary;
	//构造函数
	Employee(String n,int a,float s){
		this.name=n;
		this.age=a;
		this.salary=s;
	}
	//普通方法
	String getInfo(){
		return "name:"+this.name+"  age:"+this.age+"  salary:"+this.salary;
	}
}
public class Manager extends Employee {
	//属性
	float allowance;
	//构造函数
	Manager(String n, int a, float s,float allowance) {//继承
		super(n, a, s);//super表示当前对象的父类对象,表示父类的构造函数
		this.allowance=allowance;//this 表示当前对象
	}
	//普通方法
	String getInfo() {//覆盖,调用父类的方法(super.当前方法)+子类新增的输出
		return super.getInfo()+"  allowance"+this.allowance;
	}
}

多态

基本形态:①重载②继承③对象引用多态

什么是对象引用多态?父类引用可以指向子类对象,也可以理解为兼容
【一个对象只有一种形式,即构造函数所确定的,但是引用一个对象(父类)可以指向不同形式对象(子类)。

  • 创建一个类CalTax,用于计算税率(比如取工资的10%)
public class CalTax {//多态的应用
	void findTax(Employee e) {//Employee是父类,传入参数为子类时依旧可以使用
		System.out.println(e.salary*0.1f);
	}
public class Test {
	public static void main(String[] args) {
		//引用的多态(父类引用可以指向子类对象)
		//在创建对象时可以使用父类来创建,如以下两行
		Employee emp=new Employee("zhangsan",18,1500f);
		Employee mng=new Manager("lisi",20,2000f,500f);//对象:Manager
		
		//在调用方法时,子类可以作为传入的参数
		CalTax cal=new CalTax();
		cal.findTax(emp);
		cal.findTax(mng);
		
		//若子类对父类的方法实现覆盖,使用父类的时候,以实际对象类型为准
		System.out.println(emp1.getInfo());//emp1实际对象类型为Employee
		System.out.println(emp2.getInfo());//emp2实际对象类型为Manager
	}
}

static()

abstract抽象类

  • 类:
    ① 抽象类不能产生一个对象(不能new一个对象)
    ②抽象类可以没有抽象方法
  • 方法:
    ①抽象方法只有方法头没有方法体
    ②抽象方法必须定义在抽象类中

abstract只规定一个接口,当父类中有抽象方法时,子类(不是abstract)必须完成父类定义的抽象方法。

final最终类

  • 特点:
    ①不能被继承(不能再有子类),相当于叶子结点(但叶子结点不一定是final类)
    ②final属性的值不能被修改,相当于一个常量

访问控制符

访问控制符范围
public公共,可以被任何类使用
protected可被同包中的其他类使用,可被子类继承
无访问限定符可被同包中的其他类使用
private只限在本类中使用
  • tips
    ①所有属性都建议用private,用getname()获得
    ②父类中的私有private成员可以被子类继承,但是只能看不能用

接口interface

  • 具有抽象类的概念
    ①接口中的方法都是没有方法体的方法(public abstract 方法,修饰符可以省略)
    ②接口中的属性只能是常量(public static final 属性,修饰符可以省略)
    -接口定义的仅仅是实现某一特定功能的一组方法的对外接口和规范,但是并没有真正实现这个功能
  • 接口所规定的一组功能的实现实在继承这个接口的各个类中完成的,由这些类来具体定义接口中所有抽象方法的方法体
  • 通常把对接口的继承成为实现
  • 实现接口的类要实现接口的全部方法,如果不需要某个方法,也要定义成一个空方法体的方法:public 方法名(){}

以计算圆的面积和周长为例:

public interface CalArea {//创建一个接口,定义实现计算圆的面积的方法
	double pi=3.14;
	double calArea(double r);//仅仅是定义一个方法体
}
public interface CalCircumference {//创建一个接口,定义实现计算圆的周长的方法
	double calCircumference(double r);//仅仅是定义一个方法体
}
public class Circle implements CalArea, CalCircumference {//实现接口
//一下两个@override体现了“实现接口的类要实现接口的全部方法”
//在实现接口的类中具体定义方法体
	@Override
	public double calCircumference(double r) {
		return 2 * pi * r;
	}
	@Override
	public double calArea(double r) {
		return pi * r * r;
	}
}
public class Test {//测试
	public static void main(String[] args) {
		Circle c=new Circle();
		System.out.println(c.calArea(3.0));
		System.out.println(c.calCircumference(3.0));
	}
}

Java类库结构

  • java.lang
    System、Math、Thread、基本数据类型类
  • java.util
    向量、栈、日期…
  • java.io(用于输入输出)
  • java.net(用于网络编程)
  • java.applet(便携applet小程序)
  • java.awt(编写图形用户界面)

Object类

  • 类层次的根,每一个类都是它的子类
  • 构造方法:Object()
  • 一般方法:
    Object clone()生成当前对象的一个拷贝
    boolean equals(Object obj)比较两个对象是否相同
    Class getClass()获取当前对象所属的类信息
    String toString()用来返回当前对象本身的有关信息

数学运算的Math类()

容器类()

向量类Vector()

Java集合框架

(以下部分知识点来源:菜鸟教程)
Java集合框架图(来源:菜鸟教程)

  • 接口:是代表集合的抽象数据类型。例如 Collection、List、Set、Map 等。之所以定义多个接口,是为了以不同的方式操作集合对象

  • 实现(类):是集合接口的具体实现。从本质上讲,它们是可重复使用的数据结构,例如:ArrayList、LinkedList、HashSet、HashMap。

  • 算法:是实现集合接口的对象里的方法执行的一些有用的计算,例如:搜索和排序。这些算法被称为多态,那是因为相同的方法可以在相似的接口上有着不同的实现。
    集合框架体系(来源:菜鸟教程)

接口接口描述
Collection一个Collection代表一组Object,即Collection元素,Java不提供直接继承自Collection的类,只提供继承的子接口(如List、Set)
List接口List接口是一个有序的Collection,能够精确地控制每个元素插入的位置通过索引来访问元素,第一个元素的索引为0允许有相同的元素(不唯一)
Set具有与Collection完全一样的接口,不保存重复的元素(唯一)无序
Map提供key→value的映射

集合实现类

类描述
LinkedList实现了List接口,允许有空值,主要用于创建链表数据结构【增加、删除效率高,查找效率低】
ArrayList实现了List接口,实现了可变大小的数组【插入删除效率低】
HashSet实现了Set接口,不允许出现重复元素最多包含一个NULL元素
HashMap实现了Map接口,key→value最多允许一条记录key为空【访问速度快】

LinkedList

  • 特点
    实现了List接口
    允许有空值

  • 使用情况:
    ①通过循环访问列表中某些元素
    ②频繁地在列表各个位置进行添加、删除元素操作
    LinkList

public class Test {

	public static void main(String[] args) {
		LinkedList<String> linkedlist=new LinkedList<String>();
		//插入元素
		linkedlist.add("");//允许元素值为空
		linkedlist.add("0aa");
		linkedlist.add("0aa");//允许插入重复元素
		linkedlist.add("1bb");
		linkedlist.add("2cc");
		linkedlist.add("3dd");
		System.out.println(linkedlist); 
		/*[, 0aa, 0aa, 1bb, 2cc, 3dd]*/
		
		linkedlist.addFirst("000");//头插
		linkedlist.addLast("4ee");//尾插
		System.out.println(linkedlist);
		/*[000, , 0aa, 0aa, 1bb, 2cc, 3dd, 4ee]*/
		
		linkedlist.removeFirst();//删除头尾元素
		linkedlist.removeFirst();
		linkedlist.removeLast();
		System.out.println(linkedlist);
		/*[0aa, 0aa, 1bb, 2cc, 3dd]*/
		
		System.out.println(linkedlist.getFirst());//输出头尾元素
		System.out.println(linkedlist.getLast());
		/*0aa
          3dd*/
		
		//遍历的两种方法
		for(int i=0;i<linkedlist.size();i++) {
			System.out.print(linkedlist.get(i)+" ");
		}
		for(String str:linkedlist) {
			System.out.print(str+" ");
		}
		/*0aa 0aa 1bb 2cc 3dd */
		
		
		linkedlist.add(1,"1aa");//指定位置插入元素
		System.out.println(linkedlist);
		/*[0aa, 1aa, 0aa, 1bb, 2cc, 3dd]*/
		
		//使用iterator遍历
		Iterator<String> it=linkedlist.iterator();
		while(it.hasNext()) {
			System.out.print(it.next()+" ");
		}
		/*0aa 1aa 0aa 1bb 2cc 3dd */
	}

Arraylist

  • 特点
    实现了List接口
    允许有空值
  • 使用情况:
    ①频繁访问列表中某一元素
    ②只需要在列表末尾进行添加和删除元素操作

ArrayList

public class Test {

	public static void main(String[] args) {
		ArrayList<String> l=new ArrayList<String>();
        //添加元素
		l.add("000");
		l.add("111");
		l.add("222");
		l.add("333");
		System.out.println(l.size());//输出大小	
		System.out.println(l);
		/*4
          [000, 111, 222, 333]*/
		
		System.out.println(l.get(0));//获得0,3位置上的元素
		System.out.println(l.get(3));
		/*000
		  333*/
		
		l.set(0, "00a");//在指定位置插入元素
		l.remove(3);//删除指定位置的元素
		System.out.println(l);
		/*[00a, 111, 222]*/
		
		for(String str:l) {
			System.out.print(str+" ");
		}
		/*00a 111 222 */
		
		l.add("000");//末尾添加一个元素
		System.out.println(l);
		Collections.sort(l);//排序
		System.out.println(l);
		/*[00a, 111, 222, 000]
          [000, 00a, 111, 222]*/
		
		//使用iterator进行遍历
		Iterator<String> it=l.iterator();
		while(it.hasNext()) {
			System.out.print(it.next()+" ");
		}	
		/*000 00a 111 222*/
	}
}

HashSet

  • 特点
    实现了Set接口
    不允许有重复元素<唯一>
    最多包含一个NULL值
    无序,即不会记录插入的顺序<无序>
    HashSet
public class Test {

	public static void main(String[] args) {
		HashSet<String> hashset=new HashSet<String>();
		//添加元素
		hashset.add("000");
		hashset.add("111");
		hashset.add("222");
		hashset.add("333");
		hashset.add("444");
		hashset.add("000");
		System.out.println(hashset.size());
		System.out.println(hashset);
		/*5
	     [000, 111, 222, 333, 444]*/
	     
		//判断是否包含某元素
		System.out.println(hashset.contains("222"));
		System.out.println(hashset.contains("555"));
		/*true
	      false*/
		
		hashset.remove("444");//删除指定元素
		System.out.println(hashset);
		/*[000, 111, 222, 333]*/
	
		for(String str:hashset) {
			System.out.print(str+" ");
		}
		/*000 111 222 333 */
		
		Iterator<String> it2 =hashset.iterator();
		while(it2.hasNext()) {
			System.out.print(it2.next()+" ");
		}
		/*000 111 222 333*/
	}
}

HashMap

  • 特点
    实现了Map接口
    散列表,储存的内容是key-value的映射
    最多允许一条记录的key为NULL
    <按key值排序、唯一>
    HashMap
public class Test {

	public static void main(String[] args) {
		HashMap<Integer,String> hashmap=new HashMap<Integer,String>();
		//添加元素
		hashmap.put(1, "aaa");
		hashmap.put(1,"bbb");//唯一
		hashmap.put(10, "bbb");
		hashmap.put(3, "ccc");
		hashmap.put(7, "ddd");
		hashmap.put(6, "fff");
		System.out.println(hashmap.size());	
		System.out.println(hashmap);//hashmap按照key的值排序
		/*5
          {1=bbb, 3=ccc, 6=fff, 7=ddd, 10=bbb}*/
		
		System.out.println(hashmap.get(1));//获取key值为1、5对应的value
		System.out.println(hashmap.get(5));//key=5没有对应的value
		/*bbb
          null*/
		
		hashmap.remove(6);//移除key为6的值
		System.out.println(hashmap);
		/*{1=bbb, 3=ccc, 7=ddd, 10=bbb}*/
	

		for(int i:hashmap.keySet()) {
			System.out.print(i+"→"); 
			System.out.print(hashmap.get(i)+"  ");
		}
		/*1→bbb  3→ccc  7→ddd  10→bbb  */
		
		for(String str:hashmap.values()) {
			System.out.print(str+" ");
		}
		/*bbb ccc ddd bbb */
		

		Iterator<Integer>it2=hashmap.keySet().iterator();
		while(it2.hasNext()) {
			int x=it2.next();
			System.out.print(x+"→"+hashmap.get(x)+"  ");
		}
		/*1→bbb  3→ccc  7→ddd  10→bbb  */
	}
}

零零碎碎的知识点

  • 对于包(package),如果没有或者创建class没定义,则在默认的里面(不在包里)
  • 包名可以有层次,以小数点分隔,一般全是小写。
  • 作用:
    方便
    实现命名空间管理
    访问权限设置(public、private、protected…)

一个java程序只允许有一个public主类,其他类都为支持类(.class二进制字节码文件),一般情况下一个文件一个类

写在最后

首先深表歉意,本篇文章不是特别地完整。我目前正在学习java,刚入门,所以阅读过程中有任何错误的地方敬请指正,非常感谢大家。CSDN是一个很好的学习平台,我在这里从各位大佬的文章中汲取知识,也用写文章的方式记录自己的学习。
文章笔记会定期更新~
欢迎各位小伙伴们来一起讨论学习~

这篇关于Java入门基础知识笔记的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!