JAVA基础知识回顾202200309

JAVA基础知识点（附代码

面向对象编程思想

力图使计算机语言中对事物的描述与现实世界中该事物的本来面目尽可能保持一致

类

对一类事物的描述，是抽象的、概念的定义

class Person{
	int age;
	int getAge(){
		return age;
	}
	void set age(int i){
		age = i;
	}
}

public calss Person{
private int age;
public void setAge(int i){
	age = i;
	}
}

对象

实际存在的该类事物的每个个体，因而也称为实例

Person a = new Person();

构造方法

创建所属类型的一个新的对象

public class Person{
	public Person(String n){
		name = n;
	} 
	public Person(String n,int a){
	name = n;
	age = a;
	}
}

封装

• 目的：
  • 隐藏一个类的细节
  • 只能通过实现设定好的方法来访问数据，可以方便的加入逻辑控制，限制对属性的不合理操作；便于修改，增强代码的可维护性
  • 通过将数据封装，声明为私有。再提供一个或者多个公开的方法实现对该属性的操作

public class Father{
	private String name;
	public String getName(){
		return name;
	}
	public void setName(String name){
		this.name = name;
	}
}

方法

类的动态性能，描述该类事物所共有的功能或者行为

public class Father{
	public void hello(){
		system.out.println("hello im your Sam Father")
	}
}

继承

在已有类型的基础上进行扩充或者改进，得到新的数据类型，以满足新的需要

1.
public class Father{
	public void talk(){
		system.out.println("hello!!!");
	}
}
2.
public classs Son extends Father{
}
3.
public class Test{
	public static void main(String [],args){
		Father f = new Father();
		Son s = new Son();
		s.talk();
	}                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           
}

方法重写

在子类中可以根据需要对从父类中集成来的方法进行重新定义
简单理解：对同一个方法进行直接重写，改变他的作用但是不改变他的参数，不扩大这个方法的异常类型、不缩小这个方法的访问权限

public class Father{
	public void talk(){
		system.out.println("hello!!!");
	}
}
public class Son extends Father{
	public void talk(){
		System.out.println("wedonttalkanymore");
	}
}
public class Test{
	public static void main(String [],args){
		Father f = new Father();
		Son s = new Son();
		f.talk();
		s.talk();//两者的输出不同
	}                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           
}

方法重写的规则

• 重写方法必须与被重写方法具有相同的方法名称，参数列表，返回值类型
• 重写方法不能使用比被重写方法更严格的访问权限
• 重写方法不允许声明抛出比被重写方法范围更大的异常类型

super关键字

子类调用父类方法的情况下，使用super.fatherMethod(params)

public class Father{
	public void talk(){
		system.out.println("hello!!!");
	}
}
public class Son extends Father{
	public void talk(){
		super.talk();//声明为子类调用父类方法
	}
}
3.main test...

多态性

多态的条件

• 继承
• 被重写
• 父类引用指向子类对象

通俗的解释

• 多态允许将子类的对象当作父类的对象使用，某父类型的引用指向其子类型的对象,调用的方法是该子类型的方法。
• 这里引用和调用方法的代码编译前就已经决定了,而引用所指向的对象可以在运行期间动态绑定。再举个比较形象的例子：
  人 是父类 ；有两不同的个人 是子类
  比如有一个函数是叫某个人来吃饭，函数要求传递的参数是人的对象，可是来了一个美国人，你看到的可能是用刀和叉子在吃饭，而来了一个中国人你看到的可能是用筷子在吃饭，这就体现出了同样是一个方法，可以却产生了不同的形态，这就是多态！
• 而这个时候不能访问某个人的技能（方法），只能调用这个父类所定义的方法；注意区别，不是说不能访问子类方法，只要在父类中和子类中都有这个方法（被重写）

public clas Person{
	public void eatDinner(){
		System.out.println("yummy!");
	}
}
public class Student extends Person{
	public void eatDinner(){
		System.out.println("a student is eating dinner");
	}
}
public class Teacher extends Person{
	public void eatDinner(){
		System.out.println("a teacher is eating dinner");
	}
}
public class Test{
	public void main(String[],args){
		Person p1 = new Student();//此时触发向上转型，自动执行，将p转型为Person类型
		Person p2 = new Teacher();//同上
		System.out.println(p.getInf());//这时输出是有一个查找顺序，先看看父类有没有这个方法，无则报错；有则继续查看子类是否具有该方法；
		//而且这个时候调用的是Person的eatDinner方法，然后查找的子类方法。通过不同的声明，在调用中实现了一种方法的多种使用，这个叫做多态
		//此时只能在Person的状态使用p1或者p2，不能访问到子类的方法，只能访问到父类Person的方法
	}
}

向上向下类型转换
这篇写的不错

对象造型

引用类型数据 值之间的强制类型转换叫做 造型

-------- 规则：

• 子类到父类的类型转换 ：自动进行

	Person p = new Student();

• 多态情况下 父类到子类 必须通过造型

//合法
Person p1 = new Student();
Student s1 = (Student)p1;
//不合法
Person p2 = new Person();
Student s2 = (Student)p2;

协变返回类型

重写方法时，改变其返回值类型；但是必须是重写前返回值类型的子类或者实现类类型

public class Person{
}
public class Student extends Person{
}
public class Father extends Person{
}
public class Father{
	public Person hello(){
		System.out.println("hello from father");
		return new Father();//返回子类
	}
}
public class Son extends Father{
	public Student hello(){
		System.out.println("hello from son");
		return new Student();//返回子类
	}
}

方法重载

在一个类中存在多个同名方法的情况，重载方法参数必须不同
简单理解：重新加载此方法为同名不同方法

//一般方法重载
public class Father{
	public void hello(){
		System.out.println("hello");
	}
	public void hello(String n){
		System.out.println(n);
	}
}
//构造方法重载
public class Father{
	String gender；
	String color；
	public Father(String gender,String color){
		super();
		this.gender = gender;
		this.color = color;
	}
	public Father(String color){
		super();
		this.color = color;
	}
}

Final关键字

类、变量、方法
可以用final来修饰，使其具有终态特性
被终态标记的类 不能被继承；方法不能被子类重写；变量即成常量，只能赋值一次（在声明的同时完成赋值）
不允许用于修饰构造方法，抽象类抽象方法

public class Father{
	public final void talk(){
	System.out.printLn("hello father");
	}
	final int age = 50;
//age = 45//不合法
}
public final Son extends Father{
	public void talk(){
		System.out.println("hello Son");
	}//非法，talk已经被final，无法重写
}
public class Grandson extends Son{
}//非法，Son已被final，无法被继承

抽象方法、抽象类

抽象方法：在定义Java方法时可以只给方法头而不给方法体（方法实现细节
抽象类： 抽象方法必须使用abstract修饰，包含抽象方法的类必须声明为抽象类

public abstract class Animal{
	private int age
	public void setAge(int age){
		this.age = age;
	}
	public int getAge(){
		return age;
	}
	public abstract void eat(){
		
	}
}
public calss Bird extends Animal{
	public void eat(){
		System.out.prinln("真香~");
	}
}

抽象类主要通过集成，再由子类发挥作用

接口

抽象方法和常量值的定义的集合：一种特殊的抽象类

• 可以细线不相关的类的相同行为
• 可以被多重实现
• 可以集成其它接口，并添加新属性和抽象方法
• 支持多重继承

public interface Runner{
	public void run();
}
public interface Swimmer{
	public void swim();
}
public abstract class Animal{
	public abstract void eat();
}
public class Person extends Animal implements Runner,Swimmer{
	public void run(){
		System.out.println("run to the sunset");
	}
	public void swim(){
		System.out.println("swim to the island");
	}
	public void eat(){
		System.out.println("真香~");
	}
}

异常

程序运行过程中发生的事件可以终端程序指令的正常运行流程

TestThrowsException t = new TestThrowsException();
try{
	t.readFile()
}catch(IOException e){
	System.out.println(e);	
	}

声明抛弃异常
throws方法

集合框架

名称	特点	具体
集 set	不区分元素顺序，无重复元素	HashSet，TreeSet
列表 List	区分元素顺序，包含重复元素	ArrayList，Vector
映射 Map	保存成“键-值”信息，不包含重复的键，一个键只能映射一个值	HasMap,HashTable,TreeMap

IO输入输出

Java中I/O操作主要是指使用Java进行输入，输出操作. Java所有的I/O机制都是基于数据流进行输入输出，这些数据流表示了字符或者字节数据的流动序列。Java的I/O流提供了读写数据的标准方法。任何Java中表示数据源的对象都会提供以数据流的方式读写它的数据的方法。

IO操作