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

例如：
①包含关系：班级 学生 （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属性的值不能被修改，相当于一个常量

访问控制符

• 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集合框架

（以下部分知识点来源：菜鸟教程）

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

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

• 算法：是实现集合接口的对象里的方法执行的一些有用的计算，例如：搜索和排序。这些算法被称为多态，那是因为相同的方法可以在相似的接口上有着不同的实现。
  

集合实现类

LinkedList

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

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

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接口
  允许有空值
• 使用情况：
  ①频繁访问列表中某一元素
  ②只需要在列表末尾进行添加和删除元素操作

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值
  无序，即不会记录插入的顺序<无序>
  

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值排序、唯一>
  

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是一个很好的学习平台，我在这里从各位大佬的文章中汲取知识，也用写文章的方式记录自己的学习。
文章笔记会定期更新~
欢迎各位小伙伴们来一起讨论学习~