基础知识总结三

day01——继承

1.继承

1.1Java中的继承

继承是类和类之间的关系

继承至少得两个类：

语法格式：
class A{
  
}
class B extends A{
 
}

1.2继承的特性

• 子类拥有父类 非私有的属性和方法。
• 子类可以拥有自己的方法和属性，就是对父类的扩展。
• 子类可以用自己的方法实现父类的方法。
• Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。
• 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

1.3继承的优缺点

优点:

提高了代码的再利用性。

提高了代码的维护性。

让类与类有关，是多态的前提。

缺点:

提高类的耦合性。这样一个类的变化会影响其他与此类相关的类别。

原则：低耦合，高内聚。

耦合：类与类的关系。

内聚：自己完成某件事的能力。

打破了封装性。

1.5关于父类子类的内存分析

1.6重写

重写:是可以对父类非私有的方法进行重写,因父类提供的方法无法满足要求.

重写规则:

参数列表与被重写方法的参数列表必须完全相同。

返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类（java5 及更早版本返回类型要一样，java7 及更高版本可以不同）。

访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected。

父类的成员方法只能被它的子类重写。

声明为 final 的方法不能被重写。

声明为 static 的方法不能被重写，但是能够被再次声明。

子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。

子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。

重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。

构造方法不能被重写。

如果不能继承一个类，则不能重写该类的方法。

1.7重载

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。

每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。

最常用的地方就是构造器的重载。

重载规则:

• 被重载的方法必须改变参数列表(参数个数或类型不一样)；
• 被重载的方法可以改变返回类型；
• 被重载的方法可以改变访问修饰符；
• 被重载的方法可以声明新的或更广的检查异常；
• 方法能够在同一个类中或者在一个子类中被重载。
• 无法以返回值类型作为重载函数的区分标准。

重载与重写的区别

方法的重写 Overriding 和重载 Overloading 是 Java 多态性的不同表现。

重写 Overriding 是父 类与子类之间多态性的一种表现，

重载 Overloading 是一个类中多态性的一种表现。

如果在子类 中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象 使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一 个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重 载(Overloading)。

Day02–抽象类-Super-final

1.super关键字

只用于继承的子类中,起作用的对象是父类对象.

用法:

(1)super相当于是指向父类对象的一个指针,可以用super.父类类成员来引用父类的成员.

(2)可直接调用父类的方法

(3)引用父类的构造函数应该位于方法的第一行.

1.1与this关键字的比较.

this关键字的调用是针对当前对象的调用.

​ 可以调用属性,方法,和构造方法.

super关键字代表的是父类对象可以调用父类的成员方法和成员变量.

注意事项: super调用属性时 就是内存里面那一个调用父类的构造方法.

2.抽象类

2.1abstract关键字

abstract修饰的类叫做抽象类

abstract修饰的方法叫做抽象方法

并且abstract 只能修饰类和方法

语法格式:

abstarct class 类名｛
	普通的方法;
	public void eat () {
	
	
	}
	抽象方法;
	public abstarct void sleep ();
｝

注意事项:

1.如果一个类或者方法被abstract修饰那么这个类或方法就是抽象类或抽象方法
2.抽象类可以有普通的成员方法和抽象方法
3.抽象类不可以被实例化
4.抽象方法没有方法体,是不完整的方法.
5.抽象方法要想被使用只有写一个普通类去继承抽象方法所在的抽象类.
6.继承抽象类必须重写抽象类中的所有抽象方法.
7.非抽象方法可以不重写.
抽象类可以继承非抽象类.

• 1. 抽象类不能被实例化(初学者很容易犯的错)，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。
• 2. 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
• 3. 抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。
• 4. 构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。
• 5. 抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。

3.final修饰符

用法:

final修饰的成员变量必须初始化,并且不可以改变

final修饰的局部变量可以先不赋值,在使用前必须赋值,否则不可使用.

final修饰的成员方法不可以被重写,

final 修饰的类不可以被继承.

final修饰对象的引用,一旦被赋值就无法改变.

4.接口

关键字 接口用interface 实现接口用implements

语法格式:

interface 接口名字{
	成员变量
	成员方法
}

接口使用注意事项:

1.使用关键字 interface 声明出来一个接口

​ 2.接口面可以有属性，但是是static 和final修饰的属性。被称为常量。几乎不用

​ 3.接口下面全部抽象的方法，不带方法体的

​ 4.jdk1.8以后是可以有默认（default）的方法的，这个默认方法带有方法体【重点！！！】

​ 5.接口下面没有构造方法，不能被实例化

​ 6.去使用一个普通的类去实现这个接口，使用关键字implements

​ 7.一定要在实现类中去实现所有的抽象方法

​ 8.一个普通的类可以实现多个接口，弥补了单继承的局限性

​ 9.一个接口可以去继承另外一个接口

Day04–

static关键字

1.Java中的静态

1.1static修饰成员变量

static修饰的成员变量属于类、也称为类变量，类对象可以使用。使用时可以直接用类名调用。
定义格式：`static 数据类型 变量名；`

例子：

class A{
    static String city="China";
}
public class Demo1 {
    public static void main(String[] args) {
        A a= new A();
        System.out.println(A.city);
        a.city="中国";
        System.out.println(a.city);
    }
}

1.2static修饰成员方法

修饰成员方法时，该方法称为类方法，习惯称之为静态方法。在使用时间建议使用类名调用。

语法格式：

修饰符 static 返回值类型 方法名(){
	//执行语句
}

例子：

class A{
    static String city="China";
    public static void show(){
    	System.out.println(city);
    }
}

使用时应注意：

1、静态方法可以直接访问类变量和静态方法
2、静态方法不能直接访问普通成员变量或成员方法
3、静态方法中不可以使用this关键字

调用格式：

	被static修饰的成员可以并且建议通过类名直接访问。虽然也可以通过对象名访问静态成员，原因即多个对象均属 于一个类，共享使用同一个静态成员，但是不建议，会出现警告信息。

1.3static静态代码块

位置：类的方法外。

执行: 随着类的加载而执行。优先于main方法和构造方法的执行

顺序是：静态代码块–> 构造代码块–>构造方法。

作用：给类变量进行初始化赋值。

格式：

class A{
	static{
		//执行语句
	}
}

1.4静态代码内存分析

修饰的内容：

是随着类的加载而加载的，且只加载一次。

存储于一块固定的内存区域（静态区），所以，可以直接被类名调用。

它优先于对象存在，所以，可以被所有对象共享。

2.异常

定义：异常是程序中的一些错误，但并不是所有的错误都是异常。

异常发生的原因有很多，通常包括以下几大类;

用户输入非法数据

要打开的文件不存在

（未接触）网络通信时连接中断，或者JVM内存溢出

有关于Java异常的部分类

Exception 类是 Throwable 类的子类。除了Exception类外，Throwable还有一个子类Error 。

Java 程序通常不捕获错误。错误一般发生在严重故障时，它们在Java程序处理的范畴之外。

Error 用来指示运行时环境发生的错误。

2.1Throwable类

构造方法:

	Throwable()构造一个新的可抛出的 null作为其详细信息。
	Throwable(String message)构造一个具有指定的详细消息的新的throwable。

方法:

String	getMessage()返回此throwable的详细消息字符串。
void	printStackTrace()将此throwable和其追溯打印到标准错误流。
String	toString()返回此可抛出的简短描述。

2.2异常的分类

2.2.1错误——error

是指程序无法处理的错误，表示应用程序运行时出现的重大错误。需要重新编写代码

2.2.2异常——Exception（重点）

运行时异常：（可以不被捕获）

就是说在代码编译过程中不会表现出来，在代码运行后报异常。该类异常可以在出现异常的位置

编译时异常：

在编译时编译器会提示需要捕获，如果不进行捕获则编译错误常见的有IOException（流传输异常），SQLException（数据库操作异常）

2.2异常的分类

2.2.1错误——error

是指程序无法处理的错误，表示应用程序运行时出现的重大错误。需要重新编写代码

2.2.2异常——Exception（重点）

运行时异常：（可以不被捕获）

就是说在代码编译过程中不会表现出来，在代码运行后报异常。该类异常可以在出现异常的位置

编译时异常：

在编译时编译器会提示需要捕获，如果不进行捕获则编译错误常见的有IOException（流传输异常），SQLException（数据库操作异常）

2.3异常的处理

异常总是先被抛出，后被捕捉的。

2.3.1异常的捕捉

在程序运行时如果有异常存在我们可以捕获异常来解决运行错误

异常总是先被抛出，后被捕捉的。

语法格式：

try{
	//可能出现异常的代码块
}catch(异常对象){
	//处理异常的操作
}

如何捕获异常：首先java对于异常捕获使用的是try—catch或try — catch — finally 代码块，程序会捕获try代码块里面的代码，若捕获到异常则进行catch代码块处理。若有finally则在catch处理后执行finally里面的代码

存在的问题：面试常问问题

//问题一
try{
    //待捕获代码
}catch（Exception e）{
    System.out.println("catch is begin");
    return 1 ；
}finally{
     System.out.println("finally is begin");
}//在catch里面有一个return，finally也会被执行
//也就是说会先执行catch里面的代码后执行finally里面的代码最后才return1 
catch is begin
finally is begin  

//问题二
try{
   //待捕获代码    
}catch（Exception e）{
    System.out.println("catch is begin");
    return 1 ；
}finally{
     System.out.println("finally is begin");
     return 2 ;
}//执行了finally后已经return了，所以catch里面的return不会被执行到。也就是说finally
//永远都会在catch的return前被执行。

当抛出异常时检测到异常就结束程序的执行在try中存在多条语句需要考虑出现异常的语句

2.3.2异常的抛出

在代码出现异常的地方进行异常的抛出

如果异常的抛出的话，一旦发生异常，从出现异常的地方会终止代码

使用两个关键字:

​ throw： 在方法中抛出一个异常。自己造一个错

​ throws: 在方法的声明处书写，告知当前调用者，此处有异常。要小心

package com.qfedu.c_Exception;

import java.io.FileNotFoundException;

public class Demo8 {
	public static void main(String[] args) throws Exception{
		test(0);
		Thread.sleep(1000);
	}
	public static void test (int a) throws FileNotFoundException{
		if (a == 0) {
			//编译时异常
			throw new FileNotFoundException();
		}
		System.out.println("jvm xixi");
	}

}

throw跟throws的区别:

public void test() throws Exception {
    throw new Exception();
}

从上面这一段代码可以明显的看出两者的区别。
throws表示一个方法声明可能抛出一个异常，
throw表示此处抛出一个已定义的异常（可以是自定义需继承Exception，也可以是java自己给出的异常类）。

throw：
throw 语句用在方法体内，表示抛出异常，由方法体内的语句处理。throw 是具体向外抛出异常
的动作，所以它抛出的是一个异常实例，执行 throw 一定是抛出了某种异常。
throws：
throws 语句是用在方法声明后面，表示如果抛出异常，由该方法的调用者来进行异常的处理。
throws 主要是声明这个方法会抛出某种类型的异常，让它的使用者要知道需要捕获的异常的类
型。throws 表示出现异常的一种可能性，并不一定会发生这种异常。

2.4声明自定义异常

可以像下面这样定义自己的异常类：

class MyException extends Exception{ 

}

只继承Exception 类来创建的异常类是检查性异常类。

实例

Java 异常处理 | 菜鸟教程 (runoob.com)

以下实例是一个银行账户的模拟，通过银行卡的号码完成识别，可以进行存钱和取钱的操作。

// 文件名InsufficientFundsException.java
import java.io.*;
 
//自定义异常类，继承Exception类
public class InsufficientFundsException extends Exception
{
  //此处的amount用来储存当出现异常（取出钱多于余额时）所缺乏的钱
  private double amount;
  public InsufficientFundsException(double amount)
  {
    this.amount = amount;
  } 
  public double getAmount()
  {
    return amount;
  }
}

为了展示如何使用我们自定义的异常类，

在下面的 CheckingAccount 类中包含一个 withdraw() 方法抛出一个 InsufficientFundsException 异常。

// 文件名称 CheckingAccount.java
import java.io.*;
 
//此类模拟银行账户
public class CheckingAccount
{
  //balance为余额，number为卡号
   private double balance;
   private int number;
   public CheckingAccount(int number)
   {
      this.number = number;
   }
  //方法：存钱
   public void deposit(double amount)
   {
      balance += amount;
   }
  //方法：取钱
   public void withdraw(double amount) throws
                              InsufficientFundsException
   {
      if(amount <= balance)
      {
         balance -= amount;
      }
      else
      {
         double needs = amount - balance;
         throw new InsufficientFundsException(needs);
      }
   }
  //方法：返回余额
   public double getBalance()
   {
      return balance;
   }
  //方法：返回卡号
   public int getNumber()
   {
      return number;
   }
}

下面的 BankDemo 程序示范了如何调用 CheckingAccount 类的 deposit() 和 withdraw() 方法。

//文件名称 BankDemo.java
public class BankDemo
{
   public static void main(String [] args)
   {
      CheckingAccount c = new CheckingAccount(101);
      System.out.println("Depositing $500...");
      c.deposit(500.00);
      try
      {
         System.out.println("\nWithdrawing $100...");
         c.withdraw(100.00);
         System.out.println("\nWithdrawing $600...");
         c.withdraw(600.00);
      }catch(InsufficientFundsException e)
      {
         System.out.println("Sorry, but you are short $"
                                  + e.getAmount());
         e.printStackTrace();
      }
    }
}

编译上面三个文件，并运行程序 BankDemo，得到结果如下所示：

Depositing $500...

Withdrawing $100...

Withdrawing $600...
Sorry, but you are short $200.0
InsufficientFundsException
        at CheckingAccount.withdraw(CheckingAccount.java:25)
        at BankDemo.main(BankDemo.java:13)

Day5——String

1.学习使用

概述：
java.lang.String 类代表字符串。Java程序中所有的字符串文字（例如 "abc" ）都可以被看作是实现此类的实例。
类 String 中包括用于检查各个字符串的方法，比如用于比较字符串，搜索字符串，提取子字符串以及创建具有翻
译为大写或小写的所有字符的字符串的副本。
特点：
1. 字符串不变：字符串的值在创建后不能被更改。

1.1创建字符串

创建字符串最简单的方式如下:

String str = "Runoob";

在代码中遇到字符串常量时，这里的值是 “Runoob”，编译器会使用该值创建一个 String 对象。

和其它对象一样，可以使用关键字和构造方法来创建 String 对象。

用构造函数创建字符串：

String str2=new String("Runoob");

String 创建的字符串存储在公共池中，而 new 创建的字符串对象在堆上：

String s1 = "Runoob"; // String 直接创建 
String s2 = "Runoob"; // String 直接创建 
String s3 = s1;        // 相同引用 
直接创建时会看常量池中是否有Runoob,有的话直接引用
    //所以是s1==s2结果是true（s1==s3 true）
String s4 = new String("Runoob");   // String 对象创建 
String s5 = new String("Runoob");   // String 对象创建

关于内存分析：

https://www.runoob.com/java/java-string.html

1.2字符串的使用

方法名	参数类型	返回值类型	说明
charAt()	int	char	返回 char指定索引处的值
endsWith()	String	boolean	测试此字符串是否以指定的后缀结尾。
equals()	Object	boolean	将此字符串与指定对象进行比较。
format()	(String format, Object… args)	String	使用指定的格式字符串和参数返回格式化的字符串。
indexOf()	String int	int	返回指定字符第一次出现的下标
isEmpty()		boolean	用于判断字符串长度是否为0，为零返回ture
lastIndexOf()	类型比较多	int	用于检索指定字符串最后出现的位置。
length（）	无	int	计算字符串的长度
replace()	两个参数	String	可以用于替换字符串
split()	Spring	Spring[]	按条件分割字符串存入字符串数组中
startsWith()	单个，多个	boolean	测试字符串是否以指定字符串开始
substring()	int	String	产生子字符串
toCharArray()	无	Char[]	字符串转换为字符数组
trim()		String	用于消除字符串首尾的空格
toUpperCase()和toLowerCase()		String	可以大小写
valueOf		String	产生字符串