忘掉种过的花，重新的出发。

Ⅰ. java基础入门

Ⅱ. java面向对象

(1)类和对象的关系

A：类是对象的抽象，对象是类的实例

(2)如何定义类

A: 定义类：[访问修饰符] class 类名｛代码｝；

• 访问修饰符如public 、private 等是可选得。
• class 是声明类的关键字。
• 类型首字母大写。

(3)如何创造对象

A:定义对象：类名 对象名 =new 类名 （）；

• new是关键字。
• 左边的类名为对象的数据类型。
• 右边的类名( )为类的构造类型。

(4)如何使用对象

A:1.创造对象、2.引用对象

• 类名 对象名 =new 类名 ();
• 引用类的属性：对象名.属性
• 引用类的方法：对象名.方法

(5) 如何定义类的方法

A: [访问修饰符] 返回类型 方法名称（）｛方法体代码｝

• 访问修饰符是可选
• 返回类型 void，表明没有返回值。方法体中不必使用"ruturn"关键字返回具体数据，但是可以使用return退出方法
• 返回类型不为void，方法体一定要使用return，关键字返回对应类型的值

相同结果，有返回值情况

package hh;

public class Student {
	// 创建getName方法（有返回值）
	public String getName() {
		// return 的类型与String类型相同
		return "Aigali";
	}

	// 使用getName方法
	public static void main(String[] args) {
		Student stu = new Student();
		// 输出
		System.out.println(stu.getName());

	}
}

相同结果，无返回值的情况

package hh;

public class Teacher {
	// 创建getName方法（无返回值）
	public void getName() {
		System.out.println("Aigali");
	}

	// 使用getName方法
	public static void main(String[] args) {
		Teacher tea = new Teacher();
		// 输出
		tea.getName();

	}

}

(6)如何调用类的方法

A：相同类：直接调用；不同类，创建类对象，使用对象名.方法名（）调用

Student类的方法a()调用Student类的方法b(),直接调用

package hh;

public class Student {
	// Student类下创建b方法
	public void b() {
		System.out.print("我只是个方法b呀");
	}

	public void a() {
		// Student类下创建a方法，方法体代码引用b方法
		b();
	}

	// 使用方法
	public static void main(String[] args) {
		Student stu = new Student();
		stu.a();

	}
}

Student类的方法a()调用Student类的方法b(),直接调用

package hh;

public class Student {
	public void a() {
		/**Student类下创建a方法，方法体代码引用Teacher类下b方法
		 *先创建对象，再使用b方法
		 */
		Teacher stu = new Teacher();
		stu.b();
	}
	// 使用a方法
	public static void main(String[] args) {
		Student stu = new Student();
		stu.a();

	}
}

package hh;

public class Teacher {
	// Teacher类下创建b方法
	public void b() {
		System.out.print("我真的只是个方法b呀");
	}
}

(7)带参方法如何定义

A: [访问修饰符] 返回类型 方法名称（参数类型 参数名1，参数类型 参数名2，……）｛方法体代码｝

(8)带参方法如何使用

A：对象名.方法名（ 参数名1， 参数名2，……）

• 方法定义处的参数叫形式参数（形参），方法调用出的参数叫实际参数（实参）
• 带参方法，参数个数可以一个，也可以有多个，用逗号隔开
• 带参方法，参数名字可以随便取，符合变量命名规则
• 形参和实参名字可以不一样，但数据类型要保持一致，个数要一样，顺序要一样
• 方法有没有参数和方法有没有返回值，是两码事，毫无关系

(9)基本数据类型和引用数据类型在传递参数时的区别

A：基础基础数据类型，操作传递的是变量的值，改变一个变量的值不会影响另一个变量的值。引用数据类型（类、数组和接口），赋值是原对象的引用（可理解为内存地址）传递给另一个引用

传递参数时区别

package hh;
//创建Student类属性
public class Student {
	int age;
}

package hh;

public class Test {
	//创建Test类中的calc方法，参数基本数据类型 int
	public void calc(int ageF ){
		ageF+=1;
		//此时ageF的值
		System.out.println("ageF的值："+ageF);
	}
	//创建Test类中的calc2方法，参数引用数据类型 ，引用Student类里的studentF对象
	public void calc2(Student studentF){
		studentF.age+=1;
		//此时StudentF.age的值
		System.out.println("studentF的值："+studentF.age);
	}
}

package hh;

public class Run {
	public static void main(String[] args) {
		//引用Test类，创建test对象
		Test test =new Test();
		//age 赋值30
		int age =30;
		//调用Test类里的calc方法
		test.calc(age);
		//经过calc方法后，ageF值发生变化，age值并没有
		System.out.println("age的值："+age);
		//引用Student类，创建student对象
		Student student =new Student();
		//sudent.age 赋值10
		student.age=10;
		//调用Test类里的calc2方法
		test.calc2(student);
		//经过calc2方法后，student.ageF值发生变化，student.age值也发生变化
		System.out.println("student.age的值："+student.age);
		
	}
}

(10)如何定义构造方法

A：[访问修饰符] 构造方法名（）｛方法代码｝

• 无返回值
• 方法名与类名相同
  系统会默认生成一个方法为空的无参构造方法，如果再添加一个方法不为空的无参的构造方法，会将默认无参的覆盖掉。

(11)构造方法有何作用

A:对象初始化

• 系统提供默认无参构造方法
• 可以指定参数

★知识点：this（带参构造）

• 调用属性（当前对象）
• 调用方法（当前类）
• 调用构造函数（如果使用，必须是构造方法的第一条）

(12)方法重载的特点

A:①同一个类中②方法名相同③参数个数或类型不同④与返回值、访问修饰符无关

(13)成员变量和局部变量的区别

A:①作用域不同

• 局部变量的作用域仅限于定义它的方法
• 成员变量的作用域在整个类内部都是可见的初始值不同
  ②初始值不同
• java会给成员变量一个初始值
• java不会给局部变量赋予初始值
  在同一个方法中，不允许有同名局部变量。在不同的方法中，可以有同名局部变量
  在同一个类中，成员变量和局部变量同名时，局部变量具有更高的优先级

(14)实现封装的步骤

A:①修改属性可见值—设为private，防止错误的修改②创建公有的setter/getter方法—用于属性的读写③在getter/setter方法中加入属性控制语句----对属性合格值进行判断

• 通过setter方法设置限制，避免了属性值输入错误的问题，举一个典型的封装实例

错误示范

package example;

public class Dog {
	String name="无名氏";    //名字属性值默认“无名氏”
	String sex="雌性";			//性别属性值默认为"男"
	int health=100;			//健康值默认100，只能在0-100之间，小于60为不健康
	int love=0;			//亲密度默认0，只能在0-100之间
	public void showInfo(){
		System.out.println("狗的介绍：");
		System.out.print("狗的名字叫"+name+"是一条"+sex+"的狗，它的健康值为"+health+"，与主人的亲密度为"+love);
	}		
}

package example;

public class Run {
	public static void main(String[] args) {
		Dog dog= new Dog();  
		dog.name="旺财";	//运行类，重新赋值name“旺财”
		dog.sex="雄性";		//运行类，重新赋值sex“男”
		dog.health=-1000;	//运行类，重新赋值health-1000
		dog.love=60;		//运行类，重新赋值love60	
		dog.showInfo();
	}
	//很明显输出健康值为-1000，属性随意访问，不合理赋值
}

封装后

package example;

public class Dog {
	 String name="无名氏";    //名字属性值默认“无名氏”
	 String sex="雌性";			//性别属性值默认为"男"
	private int health=100;			//健康值默认100，只能在0-100之间，小于60为不健康
	 int love=0;			//亲密度默认0
	
	
	public void setHealth(int health){
		if(health<0||health>100){			//判断小于0，或者大于100，数值错误
			this.health=60;
			System.out.println("数值错误，健康值只能在0~100之间");
		}else{
			this.health=health;
		}
	}
	public int getHealth(){
		return this.health;
	}
	
	public void showInfo(){
		System.out.println("狗的介绍：");
		System.out.print("狗的名字叫"+name+"是一条"+sex+"的狗，它的健康值为"+health+"，与主人的亲密度为"+love);
	}		
}

package example;

public class Run {
	public static void main(String[] args) {
		Dog dog= new Dog();
		dog.name="炫神";
		dog.sex="雄";
		dog.love=0;
		dog.setHealth(-1000);				     //调用setHealth,赋health值
		System.out.println("狗的健康值："+dog.getHealth()); 	//调用getHealth,输出health
		dog.showInfo();							//调用showInfo(),查看介绍
	}
	
}

(15)如何创建包

A:
JDK提供基本包
①javalang:虚拟机自动的引入
②java.util：提供一些实用类
③java.io:输入、输出
使用：MyEclipse创建包的两种方法
①分别创建包和类
②创建类的过程中创建类所在的包

• 包名由小写字母组成，不能以圆点开头或结尾
• 包名之前最好加上唯一的前缀，通常使用组织倒置的网络域名
• 包名后续部分亦不同机构内部的规范不同而不同

(16)如何引用包

A：
import 包名.类名；
import java.util.*;//导入java.util包中所有的类
import cn.com.tencent.Game;//导入指定包中指定类

• 系统包:java.util
• 自定义包:cn.com.tecent
• *:指包中所有的类
• Game：指包中的Game类
• 一个类同时引用了两个来自不同包的同名类，必须通过完整类名区分
• 每个包都是独立的，顶层包不会包含子类的包
• package和import的顺序是固定的
  ㈠package必须位于第一行（忽略注释行）
  ㈡只允许有一个package语句（忽略注释行）
  ㈢其次是import
  ㈣接着是类的声明

(17)常用的访问权限控制符有哪儿些

(18)static在java中的应用场景及使用的注意事项

A1:
成员变量：静态变量，可以直接通过类名访问
成员方法：静态方法，可以直接通过类名访问
代码块：静态代码块，当java虚拟机加载类时，就会执行该代码
A2:
静态（static）变量：可以直接通过类名访问

• ㈠类变量
  ㈡在内存中只有一个拷贝
  ㈢类内部，可爱任何方法内直接访问静态变量
  ㈣其他类中，可以直接砼过类名访问类成员的访问控制
  ㈤能被列的所有实例共享，可作为实例之间进行交流的共享数据

静态方法：可直接通过类名访问

• ㈠静态方法中能使用this和super
  ㈡不能直接访问所属类的实例变量和实例方法
  ㈢可直接访问所属类的静态变量、静态方法

实例方法：通过实例访问

• ㈠可直接访问所属类的静态变量、静态方法、实例变量和实例方法

mian()就是最常见的静态方法
静态方法必须被实现

静态块

• ㈠当java虚拟机加载类时，就会执行改代码块
  ㈡如果有多个静态码，按顺序加载
  ㈢每个静态代码只会被执行一次

(19)继承有什么好处

A：代码中实现代码重用的重要手段之一，方便修改代码，减少代码量

(20)如何实现继承

A:
父类：[访问修饰符] class 父类名｛//公共的属性和方法｝
子类：[访问修饰符] class 子类名 extends 父类名 ｛ 子类特有室的属性和方法｝

• extends 是继承关键字
  java中只支持单根继承，即一个类只能有一个直接父类

(21)子类能（不能）继承父类什么

A1（可以继承）:①继承public和protected修饰的属性和方法，不管子类和父类是否在同一个包里②继承默认权限修饰符修饰的属性和方法，但子类和父类必须在同一个包里
A2（不可以继承）：①private成员②子类父类不同包，使用默认访问权限的成员③父类的构造方法

(22)方法重写的规则是什么

A:①两个类，有继承关系的父子类
②同名方法
③返回值类型相同或者其子类
④访问权限不能严于父类
⑤父类的静态方法不能被子类覆盖为非静态方法，父类的非静态方法不能被子类覆盖为静态方法
⑥子类可以定义与父类同名的静态方法，以便在子类中隐藏父类的静态方法（注：静态方法中不能使用super）
⑦父类的私有方法不能被子类覆盖
⑧不能抛出比父类方法更多的异常⑨

(23)super的作用是什么

== 子类方法重写父类方法，在子类中定义了和父类相同的成员变量==
使用super关键字，super代表父类对象
super只能出现在子类的方法和构造方法中
super调用构造方法时，只能是第一句
super不能访问父类的private成员

如何调用super

package example;

public class Dog extends Pet{
	public void show(){
		super.show();
		System.out.println("Dog类普通show方法新增");
	}
	
	public Dog(){
		super();
		System.out.println("Dog类无参构造方法新增");
	}
	
	public Dog(String name){
		super(name);
		System.out.println("Dog类有参构造方法新增");
	}
}
//**********************************子类Dog
package example;

public class Pet {
	public void show(){
		System.out.println("Pet类的show方法");
	}
	public Pet(){
		System.out.println("Pet类无参构造");
	}
	public Pet(String name){
		System.out.println("Pet类有参(String name)构造");
	}
}
//**************************************************父类Dog
package example;

public class Run {
	public static void main(String[] args) {
		System.out.println("调用Dog类无参构造方法:");
		Dog dog=new Dog();
		System.out.println("****************************************");
		System.out.println("调用Dog类有参构造方法:");
		Dog dog2 =new Dog("旺财");
		System.out.println("****************************************");
		System.out.println("调用Dog类普通方法:");
		Dog dog3=new Dog();
		dog3.show();
		System.out.println("****************************************");
		System.out.println("调用Dog类普通方法:");
		Dog dog4=new Dog("旺财");
		dog3.show();
	
	}
}
//运行类Run

☆this和super区别

(24)继承下的构造方法如何执行

A:
子类构造方法没有通过super显示调用父类的有参构造方法，也没通过this显示调用自身其他构造方法
系统默认调用父类的无参构造方法
子类构造方法通过super显示调用父类的有参构造方法
执行父类相应构造方法，而不执行父类无参构造方法
子类构造方法通过this显示调用自身的其他构造方法，在相应构造方法中应用以上两个规则

(25)Object类有哪儿些常被子类重写的方法

Object方法实测

package xxx;


public class Xxx {
    private String name;
    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    public Xxx(String name, int age) {
        this.name = name;
        this.age = age;
    };
    
    public static void main(String[] args) {
        Xxx x1 = new Xxx("小明", 12);
        Xxx x2 = new Xxx("小明", 12);
        System.out.println(x1.equals(x2));
        System.out.println(x1 == x2);
    }
}

Object方法重写后

package xxx;
public class Xxx {
    private String name;
    private int  age;
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }


        public  Xxx(String name,int  age){
         this.name=name;
         this.age=age;
        };

    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }

        if (!(obj instanceof Xxx)) {
            return false;
        }
        Xxx s = (Xxx) obj;
        if (this.age == s.getAge() && this.name.equals(s.getName())) {
            return true;
        } else {

            return false;

        }
    }
    public static void main(String[] args) {
    Xxx x1=new Xxx("小明",12);
    Xxx x2 =new Xxx("小明",12);
        System.out.println(x1.equals(x2));
        System.out.println(x1==x2);
    }
}

(26)如何实现多态

(27)多态有哪儿两种常见的应用方式

(28)抽象类与与普通类的区别

①抽象类不能被实例化–可以创建一个引用变量，其类型是一个抽象类，指向非抽象的子类实例
普通类可以被实例化
②抽象类没有方法体
普通类有方法体

(29)使用抽象类

抽象类可以没有抽象方法，单包含了抽象方法的类必须被定义为抽象类
如果子类没有实现父类的所有抽象方法，子类必须被定义为抽象类
没有抽象构造方法，也没有抽象静态方法
抽象类中可以有非抽象的构造方法，创建子类的实例时可能调用

(30)使用接口的作用

接口的存在弥补了java单根继承的缺点

(31)什么是接口

概念性的接口。指系统对外提供的所有服务
interface定义的实实在在的接口，即接口类型

(32)如何定义接口

[访问修饰符] interface 接口名称 [extends 其它接口名]｛
//声明变量
//声明方法
｝

(33)接口定义时注意的规则

JDK8之前：
接口中的变量都是静态常量（public static final）,必须显示初始化
接口中所有方法默认都是public abstract
接口没有构造方法，不可以被实例化，但可以被实现（常作为类型使用）
实现类必须实现接口的所有方法
实现类可以实现多个接口（java中的多继承）
implements、多个接口使用逗号隔开。

(34)JDK8新增接口特性

①接口里可以有默认方法 （方法体）
default 关键字的默认方法

default void 方法名{}

默认方法可以被继承，通过实例调用
如果一个类实现了多个接口。多个接口都定义了相同的默认方法
方案一：实现类需要覆盖重写接口中的默认方法
方案二：重写，可以使用super，来调用指定接口的默认方法

[父接口名].super.方法名()

如果一个类继承了一个抽象类，实现了一个接口，抽象类和接口存在相同的方法：
采取类优先原则，优先继承抽象类的方法
接口默认方法可以有多个
作用：解决了接口与其实现类之间耦合度过高，修改接口，所有实现类必须随之修改的问题。
②接口可以声明（并且可以提供实现）的静态方法了

static void 方法名{}

接口中的静态方法必须是public的，public修饰符可以省略，static修饰符不能省略
静态方法不能被继承及覆盖，所以只能被具体所在的接口调用
接口中静态方法可以有多个
作用：帮我们实现静态工厂类（工具类），不用重新创建工具类了。

Ⅲ.java高级API

(1)Collection、List、Set、Map接口的联系和区别

(2)ArrayList和LinkedList的异同之处及各自的应用场合

(3)遍历的方法

有序集合

普通for遍历索引
增强for遍历索引
增前型for
迭代器Iterator

无序集合

增强型for
迭代器for

(4)使用Map存储数据

(5)泛型的好处及使用

(6)Collections的好处及使用

(7)实现一个类的对象之间比较大小

(8)定义并使用枚举类型（enum）

(9)包装类、装箱&拆箱

(10)使用Math类进行数学运算

(11)会使用Random类获取随机数