Java基础笔记

HaungRD

已于 2022-11-22 08:58:38 修改

阅读量664

点赞数

文章标签： java 开发语言后端

于 2021-12-26 11:42:21 首次发布

本文链接：https://blog.csdn.net/weixin_57654074/article/details/122153296

版权

JAVA笔记

>个人博客：www.huangrd.top，欢迎访问学习更多知识。

五、继承与多态

5.1继承

实现代码的重用，提高程序的可维护性。

5.1.1继承的概念

5.1.2子类对象的创建

[修饰符] class 子类名 extends 父类名
    class Cattle extends Animal{
        
    }

5.1.3继承的使用原则

1.子类只能继承父类的protected和public；

2.子类能继承同一个包中默认修饰符修饰的成员变量和方法；

3.子类的成员变量如果与父类相同，则隐藏父类的成员变量；

4.子类的成员方法如果与父类相同，则覆盖父类的成员方法；

5.1.4关键字super

子类访问父类中被子类隐藏的成员变量、方法，使用关键字super

super的作用
    //1.调用父类的构造方法
    super([参数列表])；
    //2.操作被隐藏的成员变量和被覆盖的成员方法
    super.成员变量名
    super.成员方法名([参数列表])

5.2子类的继承

Java中，任何类都继承于 Object类，除Object类外，每个类只能有一个父类，但可以有多个子类。

1.同一包中的子类和父类

子类和父类在同一包中，则子类会继承父类中非private修饰的成员变量和方法。’

2.非同一包的子类与父类

子类和父类不在同一包时，子类不会继承父类中private和友好成员变量和方法。

5.3多态

在Java中，通过重载Overloading和覆盖Overriding实现类的多态性。

1.方法的重载

参数个数、参数类型不同来重载方法。

ps:方法的返回值类型不能用来重载。

2.避免歧义

3.方法的覆盖

当子类继承父类时，如果子类的方法名和父类方法名相同，则子类不能继承父类的成员方法。称为覆盖。

覆盖体现了子类补充或改变父类的能力。

ps:

子类不能覆盖父类声明为final或static的方法。
子类必须覆盖父类声明为abstract的方法，或者子类将该方法声明为abstract。
子类覆盖父类的方法时，子类方法的声明必须和父类方法的声明相同。

4.向上转型

取得一个对象的引用并将它看做超类类型的对象，成为向上转型。

public class Zoos {
    public void free(Animal animal){
        animal.move();
    }
}
abstract class Animal{//抽象类
    public abstract void move();//移动方法
}
class Parrot extends Animal{
    public void move(){
        System.out.println("鹦鹉正在飞");
    }

    public static void main(String[] args) {
        Zoos zoos = new Zoos();
        Parrot parrot = new Parrot();
        Tortoise tortoise = new Tortoise();
        zoos.free(parrot);
        zoos.free(tortoise);
    }
}
class Tortoise extends Animal{
    public void move(){
        System.out.println("乌龟正在爬");
    }
}

5.4抽象类

1.抽象类和抽象方法

抽象类，就是只声明方法的存在而不去实例化他的类。
抽象类不能实例化。
抽象类关键字abstract。

//语法格式如下
abstract class 类名{
    类体
}

抽象方法：

在抽象类中创建、没有实现、必须由子类重写的方法称为抽象方法。
抽象方法只有声明，没有实现。
抽象方法关键词abstract。
抽象方法不能用关键字private和static修饰。

//语法格式如下
abstract <方法返回值类型> 方法名 （参数列表）

2.抽象类和抽象方法的规则

抽象类和抽象方法必须使用abstract来修饰。
抽象类不能实例化，即使抽象类不含抽象方法也不能实例化。
抽象类可以包含属性、方法、构造器、初始化块、内部类和枚举类。抽象类中的构造器不能创建用例，主要用于被其子类调用。
含有抽象方法的类只能被定义为抽象类。

5.5关键字final

关键字final用来修饰类、变量和方法，表示他修饰的类、变量和方法不能改变。

1. final变量

final修饰变量，表示该变量一旦获得初始值之后就不可以被改变。可以用来修饰成员变量、局部变量、形参。

2. final类

final修饰的类，该类不能被继承，不能有子类。

//语法格式如下
final class 类名{
    类体
}

3. final方法

final修饰的方法，表示该方法不能被重写。可用来禁止子类重写父类的方法。

5.6.内部类

在其他类内部定义的子类。

//eg
public class Zoo{
    class Wolf{//内部类
        
    }
}

1.成员内部类

成员内部类和成员变量一样，属于类的全局成员。

！！！成员内部类不可以使用public 修饰，每个Java类文件只允许使用一个public修饰的公共类（公共类名称必须与类文件同名）

2.局部内部类

和局部变量类似，在方法内定义，只在方法内部有效。

public void sell(){
    class Apple{//  局部内部类
    
    }
}

3.静态内部类

和静态变量类似，使用static修饰。

public class Sample{
	static class Apple{//静态内部类
	
	}
}

4.匿名内部类

没有名称的内部类，常被应用到Swing程序设计的事件监听。

特点：

匿名内部类可以继承父类方法，也可以重写父类方法；

匿名内部类可以访问外嵌类中的成员变量和方法，在匿名内部类中不能声明及港台变量和静态方法。

使用匿名内部类时，必须在某个类中直接使用匿名内部类创建对象。

使用匿名内部类创建对象时，需要直接使用父类的构造方法。

//一般格式如下
new ClassName(){

}
//创建一个匿名的Apple类
public class Sample{
	public static void main(String[] args){
		new Apple(){
			public void introduction(){
				System.out.println("这是一个匿名对象");
			}
		}
	};
}

匿名对象经常创建接口的唯一实现类，或者创建某个类的唯一子类。

interface Apple{//定义Apple接口
    public void say();//定义say方法
}
public class Sample {//创建Sample类
    public static void print(Apple apple){//创建print()方法
        apple.say();
    }
    public static void main(String[] args) {
        Sample.print(new Apple() {//为print()方法传递参数
            @Override
            public void say() {//实现Apple接口
                System.out.println("这是一箱苹果");//匿名内部参数传递
            }
        });
    }
}

六、接口

Java仅支持单继承，不支持多继承。为了解决这种问题，Java提供接口来实现类的多继承功能。

6.1接口简介

Java中接口是一个抽象的类，接口中的所有方法都没有方法体。

6.2接口的定义

Java使用关键字interface来定义一个接口。接口和类的定义类似，也分为接口的声明和接口体，接口体由常量定义和方法定义来实现。

//语法格式如下
[修饰符] interface 接口名 [extends 父类接口列表]{
	[public] [static] [final] 常量;
	[public] [abstract] 方法;
}
//修饰符 public

接口类文件必须与接口名相同。

6.3借口的继承

接口可以有多个直接父类接口，继承时获得父类接口中定义的所有抽象方法、常量属性。

public interface interfaceC extands interfaceA,interfaceB{

}

6.4接口的实现

接口可以被类实现，也可以被其他接口继承。在类中实现接口使用关键字implements

//语法格式如下
[修饰符] class <类名> [extends 父类名] [implements 接口列表]{

}
//修饰符 public final abstract

6.5接口与抽象类

共同点：

接口和抽象类都不能实例化，但都能被其他类实现和继承；
接口和抽象类都可以包含抽象方法，实现接口或者继承抽象类的普通子类必须包含这些抽象方法；

差别：

子类只能继承一个抽象类但可以实现多个接口；
一个类若要实现一个接口，则必须实现接口的所有抽象方法，而抽象类则不用；
抽象类的成员变量可以是各类型的，而接口只能是public、static、final类型的；
接口只能定义抽象方法，抽象类可以定义非抽象方法；
抽象类可以有静态方法和静态代码块，接口中不可以；
接口不能被实例化，没有构造方法，而抽象类可以有构造方法；

6.6接口的 UML 图

接口是Java的一种数据类型。
使用接口声明的变量称为接口变量。
接口变量是引用型的变量。

public interface People {
    void Say(String S);             //定义一个接口
}
public class Teacher implements People{
    public void Say(String s){          //Teacher类实现接口
        System.out.println(s);
    }
}
public class Student implements People{
    public void Say(String s){
        System.out.println(s);         //Student类实现接口
    }
}
public class App {
    public static void main(String[] args) {
        People p;                           //声明接口变量
        p=new Teacher();                    //接口变量中存放对象的引用
        p.Say("我是老师");                 //接口回调
        p=new Student();                    //接口变量中存放对象的引用
        p.Say("我是学生");                 //接口回调
    }
}

6.8接口与多态

6.9接口参数

public interface Eatfood {
    void Eatfood();
}
public class Chinese implements Eatfood{
    public void Eatfood(){
        System.out.println("中国人用筷子吃饭");
    }
}
public class America implements Eatfood{
    public void Eatfood(){
        System.out.println("美国人习惯用刀叉吃饭");
    }
}
public class EatMethods {
    public void lookEatMethods(Eatfood eat){//定义接口类型的参数
        eat.Eatfood();                      //接口回调
    }
}
public class Example2 {
    public static void main(String[] args) {
        EatMethods em=new EatMethods();
        em.lookEatMethods(new Chinese());
        em.lookEatMethods(new America());
    }
}

6.10面向接口编程

一种多态的体现。

七、异常处理

异常处理检查可能出现的错误，以保证程序的可读性和和维护性。在Java中，会将异常封装到一个类中，当出现错误时，就会抛出异常。

7.1异常的描述

程序运行时出现的错误被称为异常。

public class Baulk {
    public static void main(String[] args) {
        int result = 3 / 0;
        System.out.println(result);
    }
}

7.2异常的分类

异常是Throwable类的子类。Throwable 类派生了两个子类，分别是Error类和Exception类。

1.系统错误———Error

描述Java运行时系统内部错误及资源耗尽错误。该类常规下不能捕获异常，如OutOfMemororyError、ThreadDeath。这些错误发生时，JVM会选择终止线程。

2.异常——Exception

1.运行时异常

在程序运行过程中产生的错误，是RuntimeException类及其子类异常，如NullPointerException、IndexOutOfBoundsException。

2.非运行时异常

除RuntimeException类及其子类以外的异常。这类异常必须处理，否则无法通过编译。如IOException、SQLException及用户自定义异常。

7.3捕捉并处理异常

1.try...catch代码块

try...catch主要用来对异常进行捕捉并处理，在使用时，还有一个可选的finally代码块

try{
	//程序代码块
}
catch(Exceptiontype e){
	//对Exceptiontype的处理
}
finally{
	//代码块
}
//Exceptiontype是try代码块传递给catch代码块的类型，e是对象名。

Exception对象提供了获取异常的3种方法。

//getMessage()方法:获取相关异常事件信息
//toString()方法：获取异常的性质与类型
//printStackTrance()方法：获取异常事件发生执行堆栈的内容

public class Take {                              //创建类
    public static void main(String[] args) {     
        try {                                    //try代码块中包含可能出现异常的代码
            String str = "lili";                 
            System.out.println(str + "年龄是：");
            int age = Integer.parseInt("20L");
            System.out.println(age);    
        }catch (Exception e){                    //catch代码块来获取异常信息
            e.printStackTrace();                 //输出异常性质
        }
        System.out.println("program over");      //输出信息
    }
}

2.finally代码块

完整的异常处理语句应包含finally代码块，通常情况下，无论程序是否有异常发生，finally代码都能正常运行。

这三种情况下，finally代码快不会被执行：

finally代码块发生异常；
前边代码使用System.exit()方法退出程序；
程序所在线程死亡；

7.4在方法中抛出异常

1.使用关键字throws抛出异常

在声明方法时使用

//语法格式如下
返回值类型名 方法名 (参数列表) throws 异常类姓名{
	方法体
}

public class Shoot {
    static void pop() throws NegativeArraySizeException {
        //定义方法并抛出 NegativeArraySizeException异常
        int []arr = new int[-6];
    }

    public static void main(String[] args) {
        try{                                        //try语句处理异常信息
            pop();
        }catch (NegativeArraySizeException e){
            System.out.println("pop()方法抛出的异常");//输出的异常信息
        }
    }
}

2.使用关键字throw抛出异常

在方法体中使用

//语法格式如下
throw new 异常类型名(异常信息);

public class ThrowTest {
    public static void main(String[] args) {
        int num1 = 25;
        int num2 = 0;
        int result;
        if (num2 == 0){
            //抛出ArithmeticException异常
            throw new ArithmeticException("除数不能为0");
        }
        result = num1/num2;
        System.out.println(result);
    }
}

关键字throw通常用来抛出用户自定义异常。

throws和throw的区别：

关键字throws用在方法声明的后面，表示抛出异常，有方法调用者处理，而关键字throw用在方法体内，用来制造一个异常，由体内的语句处理；
关键字throws用于声明这个方法会抛出这种类型的异常，以使他的调用者知道要捕捉这个异常，而关键字throw用于直接抛出一个异常的案例；
关键字throws表示出现异常的一种可能性，并不一定会发生某种异常，但如果使用关键字throw，就一定会发生某种异常。

7.5自定义异常

步骤：

创建自定义异常类；

在方法中通过关键字throw抛出异常对象；

如果想要在当前抛出异常类的方法中处理异常，则可以使用try...catch代码块捕捉并处理异常，或在方法的生命处理中船舰一个自定义异常类MyException,该类继承于Exception类。

public class MyException extends Exception{     //创建一个自定义类MyException
    public MyException(String ErrorMessage){    //构造方法
        super(ErrorMessage);                    //父类构造方法
    }
}
public class Tran {
    static void avg(int age) throws MyException{
        if(age<0){
            throw new MyException("年龄不能为负数");
        }
        else{
            System.out.println("王师傅今年"+age+"岁了！");
        }
    }

    public static void main(String[] args) {
        try{
            avg(-50);
        }catch (MyException e){
            e.printStackTrace();
        }
    }
}

自定义一场主要用于一下场合

使异常信息更加具体；
程序某些错误符合Java语法，但不符合实际情况；
在分层软件架构中，通常由表现层进行异常捕捉和处理；

7.6异常的处理原则

不要过度使用异常处理；
不要使用庞大的try...catch代码块；
避免使用catch(Exception e);
不要忽略捕捉到的异常；
如果父类抛出多个异常，则覆盖方法必须抛出相同的异常或者其异常的子类，不可以抛出新的异常。

八、常用类

8.1 String类

java.lang.String

1.创建字符串对象

声明字符串
String 字符串标识符;
声明并初始化字符串常用方式
String 字符串标识符  = 字符串;
通过构造方法创建并初始化字符串对象
String varname = new String ("theString");

空字符串并不是说他的值等于null。” “空字符串也是有符号定义的，实例化的对象。

2.连接字符串

连接字符串可通过 + 实现。

3.字符串操作

1.比较字符串

equals()方法。

equals()定义如下
public boolean equals(String str);

String str = "A";
boolean b = str.equals("a");
//相同返回true，不同返回flase

equals()比较的是字符串对象的内容，而 ==比较的是两个对象的内存地址。

equalsIgnoreCase()方法。

比较时不区分大小写

定义：
public boolean equalsIgnoreCase(String str)

String str = "A";
boolean b = str.equalsIgnoreCase("a");

startsWith()方法和endsWith()方法。

分别判断字符串是否以指定的字符串开始或结束

定义如下:
public boolean startsWith(String str)
public boolean endsWith(String str)

String str = "ABCDE";
boolean bs = str.startsWith("a");
boolean be = str.endsWith("DE");

startsWith()的重载方法,判断字符串从指定索引开始是否为指定的字符串。

定义如下
public boolean startsWith(String prefix,int toffset)

String str = "ABCDE";
boolean b = str.startWith("CD",2);

compareTo()方法。

用于判断一个字符串是大于、等于还是小于另一个字符串。判断依据是他们在字典中的顺序。

定义如下
public int compareTp(String str)

2.获取字符串的长度

length()方法

String nameStr = "HuangRuiDong";
int i = nameStr.length();

3.字符串大小写转换

toLowerCase(); 将字符串所有大写字母改成小写
toUpperCase(); 将字符串所有小写字母改大写

4.查找字符串

indexOf()方法用于搜索字符或字符串首次出现的位置

lastIndexOf()方法用于搜索字符或字符串最后出现的位置

5.截取字符串

substring()方法，可以从现有字符串中截取子字符串。

public String substring(int beginIndex)
public String substring(int beginIndex,int endIndex)

6.去掉字符串的首尾空格

public String trim()

7.替换字符串中的字符或子字符串

定义
public String replace(char oldChar,char newChar)//替换原字符串的字符
public String repalceAll(String regex,String replacement)//替换原字符串的子字符串
public String replaceFirst(String regex,String replacement)//替换原字符串的第一个字符or字符串

8.分割字符串

String类提供了两个重载的split()方法，用于将字符串按照指定的规则分割，并以String型数组的返回方式。

public String[] split(String regex,int limit)
//regex为分割规则，limit为分割规则的使用次数

4.格式化字符串

通过format（）方法，可以得到经过格式化的字符串对象。format（）方法常用于对时期和时间进行格式化。

public static String format(String format,Object obj)
public static String format(Locale locale,String format,Object obj)

5.对象的字符串表示

所有类都默认继承Object类，Object类位于java.lang包中。在Object类中有一个public String toString()方法,这个方法用于获取对象的字符串表示。

public class app{
	public static void main(String[] args){
		Object obj = new Object();
		System.out.println(obj.to String());
	}
}

8.2 StringBuffer类

StringBuffer和String都表示字符串，只不过String不可修改，而StringBuffer可以修改。

1.StringBuffer对象的创建

1.StringBuffer对象的初始化

StringBuffer s = new StringBuffer();
StringBuffer s = new StringBuffer("130");

StringBuffer和String不能直接进行强制类型转换。

2.StringBuffer 类的构造方法

StringBuffer()
StringBuffer(int size)//指定容量
StringBuffer(String s)//在s的基础上+16个字符

StringBuffer类似于vector，可通过length（）方法获得其实际长度，通过capacity（）方法获得其容量。

2. StringBuffer的常用方法

append()方法。将其他Java类型数据转化为字符串，再追加到StringBuffer对象的字符内容的末尾。
charAt()方法。charAt(int n)方法获取参数n位置上的单个字符，charAt(int n,char ch)用于把参数n位置上的字符换为ch.
insert(int index,String str)方法。将str插入到当前StringBuffer对象index位置处。
reverse()方法。字符串反转。
delete(int startIndex,int endIndex)方法。删除字符串，从startIndex到endIndex-1的位置结束。
replace(int startIndex,int endIndex，String str)方法。从startIndex到endIndex-1的位置替换str.

8.3日期的格式化

1. Date类

Date类位于java.util包中

Date date = new Date();//无参构造
Date date = new Date(10000);//计算机本身的时间为1970年1月1日0时，即格林尼治时间。参数表示与格林尼治的时间差，正数为之后的时间，单位ms

2.格式化日期和时间

，

8.4 Math类和Random类

1. Math类

位于java.lang包中

//常见方法
两个常量 E PI
abs();
max();
min();
pow();
sqrt();
log();
sin();
asin();
random();

2.Random()类

Random类位于java.util包中

获得随机数

构造方法
public Random();//无参构造
public Random(long seed);//有参构造
Random rd = new Random();
rd.next();
rd.next(m);//返还一个0~m的随机数

8.5 包装类

1. Integer类

java.long包中的Interger、Long、Short分别将int、long、short封装成一个类。

1.构造方法

Integer(int number)
Integer(String str)
str必须为数值型，后则会抛出异常NumberFormatException

2.常用方法

byteValue();//返还byte型的Integer对象的值
Int compareTo(Integer anotherInteger);//数值上比较两个对象的值，相等0，大于，正值，小于，负值；
boolean equals(Object IntegerObj);//比较此对象与指定对象是否相等
int intValue();
short shortValue();
String toString();
Integer valueOf(String str);//返回保存指定String对象的值的Intager对象
int parseInt(String str);//返回包含在由str指定的字符串中的数字的等价整型值

3.常量

MAX_VALUE
MIN_VALUE
SIZE
TYPE

2. Boolean类

1.构造方法

Boolean(boolean value)
Boolean(String str)//str不为null且忽略大小写时为true

2.常用方法

boolean booleanValue();
boolean equals(Object Obj);//比较此对象与指定对象是否相等,表示同一个对象是才会true
boolean parseBoolean(String s);//将字符串参数解析为boolean值
String toString();
Boolean valueOf(String str);//返回保存指定String对象的值的Boolean对象

3.常量

TRUE
FALSE
TYPE

3. Byte类

1.构造方法

Byte(int number)
Byte(String str)
str必须为数值型，后则会抛出异常NumberFormatException

2.常用方法

byteValue();//返还byte型的Integer对象的值
int compareTo(Integer anotherByte);//数值上比较两个对象的值，相等0，大于，正值，小于，负值；
boolean equals(Object \Obj);//比较此对象与指定对象是否相等
Int intValue();
double doubleValue();//以double值返回Byte的值
String toString();
Byte valueOf(String str);//返回保存指定String对象的值的Byte对象
int parseByte(String str);//返回包含在由str指定的字符串中的数字的等价整型值

3.常量

MAX_VALUE
MIN_VALUE
SIZE
TYPE

4. Character类

1.构造方法

Character(char value)

2.常用方法

char charValue();//返回此对象的值
int compareTo(Character anotherCharacter);//数值上比较两个对象的值，相等0
boolean equals(Object Obj);//比较此对象与指定对象是否相等
char toUpperCase(char ch);//字符转大写
char toLowerCase(char ch);//字符转小写
char charValue();
short shortValue();
String toString();
boolean isUpperCase(char ch)//判断指定字符是否为大写字符
boolean isLowerCase(char ch);//判断指定字符是否为小写字符

3.常量

CONNECTOR_PUNCTUATION
UNASSIGNED
TITLECASE_LETTER

5. Double类

1.构造方法

Double(double number)
Double(String str)
str必须为数值型，后则会抛出异常NumberFormatException

2.常用方法

byteValue();//返还byte型的Integer对象的值
int compareTo(Double d);//数值上比较两个对象的值，相等0，大于，正值，小于，负值；
boolean equals(Object Obj);//比较此对象与指定对象是否相等
int intValue();
boolean isNaN();//判断是否为非数字，是true，否false
String toString();
Double valueOf(String str);//返回保存指定String对象的值的Double对象
double doubleValue();//以double返回此对象的值
long longValue();//以long返回此对象的值,强制转换为long

3.常量

MAX_EXPONENT
MIN_EXPONENT
NEGATIVE_INFINITY
POSITIVE_INFINITY

6. Number类

Number类是抽象类，是BigDecimal、BigInteger、Byte、Double、Float、Integer、Long、和Short的父类。

//常用方法
byte byteValue();
int intValue();
float floatValue();
short shortValue();
long longValue();
double doubleValue();

HaungRD

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java基础笔记

JAVA基础笔记
复制链接

扫一扫

Java基础笔记

JAVA笔记

>个人博客：www.huangrd.top，欢迎访问学习更多知识。

五、继承与多态

5.1继承

5.2子类的继承

5.3多态

5.4抽象类

5.5关键字final

5.6.内部类

六、接口

6.1接口简介

6.2接口的定义

6.3借口的继承

6.4接口的实现

6.5接口与抽象类

6.6接口的 UML 图

6.8接口与多态

6.9接口参数

6.10面向接口编程

七、异常处理

7.1异常的描述

7.2异常的分类

7.3捕捉并处理异常

7.4在方法中抛出异常

7.5自定义异常

7.6异常的处理原则

八、常用类

8.1 String类

8.2 StringBuffer类

8.3日期的格式化

8.4 Math类和Random类

8.5 包装类

“相关推荐”对你有帮助么？