java基础（二）

最新推荐文章于 2022-04-14 15:24:37 发布

happyhwq

最新推荐文章于 2022-04-14 15:24:37 发布

阅读量206

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/weixin_43461465/article/details/104130627

版权

java 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

字符串

String类对象实例化的两种方法及其优缺点

String 在使用中有两种实例化的方法:
一种是采用直接赋值(将字符串赋String的对象);
第二种方法是通过构造方法完成实例化的操作，方法如下:

方法名称	描述
public String(Stringoriginal)	接收 String 对象，实例化 String 类

采用直接赋值(将字符串赋String的对象)的形式实例化String对象

public static void main(String args[]) {
	String str = "Hello"; // 定义一个字符串 
	str += " World"; // 字符串连接 
	System.out.println(str);
}

通过构造方法完成实例化

public static void main(String args[]) {
	String str = new String("Hello"); // 定义一个字符串 
	str += " World"; // 字符串连接 
	System.out.println(str);
}

为什么String类是不可变类?

在 Java 中，String 类是不可变的。那么到底什么是不可变的对象呢?

可以这样认为：如果一个对象，在它创建完成之后，不能再改变它的状态，那么这个对象就是不可变的。不能改变状态的意思是，不能改变对象内的成员变量，包括基本数据类型的值不能改变，引用类型的变量不能指向其他的对象，引用类型指向的对象的状态也不能改变。

字符串的比较

两个数字之间直接使用= =进行判断，String 对象也同样可使用进行相等判断。
但是= =用在数值上表示判断是否相等，如果是用在了对象上，则表示的是判断两个对象的地址是否相等。

Sting中，==和equals()的区别

两种比较的区别:==和equals()
==:用于数值比较，比较的是两个字符串的地址值
equals():用于内容的比较，比较两个字符串的内容是否相等

类和对象

类是一个通用的概念，Java、C++、C#、PHP 等很多编程语言中都有类，都可以通过类创建对象。可以将类看做是结构体的升级版，C 语言的晚辈们看到了 C 语言的不足，尝试加以改善，继承了结构体的思想，并进行了升级，让程序员在开发或扩展大中型项目时更加容易。

面向对象编程强调“封装”，“继承“和“多态”，这三者被称为面向对象的三大特性

类与对象的概念与定义

类与对象的的命名规范
· 定义类名称的时候，每个单词的首字母大写:HelloInfo
· 定义方法名称的时候，第一个单词的首字母小写，之后每个单词的首字母大写:
printInfo()
· 定义属性的时候，第一个单词的首字母小写，之后每个单词的首字母大写:
empName
· 定义常量的时候，所有的单词字母都要大写:INFO
· 定义包名称的时候，所有的单词的字母都要小写:org.demo

封装性

通过getter/setter对属性进行访问

如果希望属性或方法不被类外部所访问的话，则可以使用 private 关键字声明，实现属性的封装。根据 private 的特性，一旦属性被封装之后，访问就成为了一个问题，因为 private 类型的属性或者方法，只能在本类中使用。因此必须给被封装的属性一个设置值和取得值得方法。

所以在 JAVA 开发的标准规定中，只要是属性封装，则设置和取得就要依靠 setter 及 getter 方法完成操作。

举例说明：

public class Main {

    public static void main(String argbs[])
    {
        Person person = new Person();
        person.setName("leilei");
        person.setAge(18);
        person.tell();
    }
}
class  Person
{
    private String name;
    private int age;

    public void setName(String n) {
        name  = n;
    }
    public void setAge(int a){
        if(0<a&&a<150)
            age = a;
    }
    public String getName(){
        return  name;
    }
    public int getAge(){
        return age;
    }
    public int tell()
    {
        System.out.println("name = "+name+",age = "+age);
        return 0;
    }
}

运算结果：

name = leilei,age = 18

这种写法变成了 Java 中的一个标准:只要是属性就必须进行封装，封装之后的属性必须通过 setter 和 getter 设置和取得。

构造方法

但在Person类中并没有定义该方法，为什么还能调用Person()方法?这是因为，在一个类中如果没有明确的定义一个构造方法的话，则会自动生成一个无输入参数的，什么都不做的构造方法。该构造方法又称为默认的构造方法。

小结

本章是面向对象的核心知识，对象和类。可以说，Java 面向对象是围绕类和对象展开的，因此类与对象的概念的理解就显得尤为重要。

封装性

本章中，介绍了面向对象的第一个特征:封装性。封装的含义实际上是“封装数据”，在类中，所谓的数据就是属性，或者叫做成员。属性封装以后，类外部要进行访问，必须通过类中定义的公共的方法进行。

构造方法

本章中的构造方法也是重要的概念之一，一般情况下，构造方法用作初始化对象的参数
值。

对象在内存中的表示和对象的引用传递

对象在内存中的表示和对象的引用传递需要深刻理解。

static

static的理解有助于提高内存的利用率，注意其用法。

内部类

内部类在应用过程中较少见到，在Java的Swing编程和JDBC中用的较多。内部类最大的优点就在于它能够非常好的解决多重继承的问题，但是如果我们不需要解决多重继承问题，那么我们自然可以使用其他的编码方式，但是使用内部类还能够为我们带来如下特性。：
1.内部类可以用多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互独立。
2.在单个外围类中，可以让多个内部类以不同的方式实现同一个接口，或者继承同一个类。
3.创建内部类对象的时刻并不依赖于外围类对象的创建。
4.内部类并没有令人迷惑的“is-a”关系，他就是一个独立的实体。
5.内部类提供了更好的封装，除了该外围类，其他类都不能访问。

常用类

StringBuffer类

public class Main{
    public static void main(String[] args) throws Exception{
        StringBuffer buf = new StringBuffer();
        buf.append("Hello").append(" World.");
        fun(buf);
        System.out.print(buf);
    }
    public static void fun(StringBuffer temp){
        temp.append("\n").append("Hellp MLDN");
    }
}

运行结果：

Hello World.
Hellp MLDN

StringBuffer 类之中使用 append()方法进行数据的连接。

Runtime类

System类

日期操作类

数学公式类:Math

大数字操作类

枚举

未完待续
看不下去了下次再补充

继承

与C++相比，JAVA只支持单继承，并不支持多重继承。单继承使JAVA的继承关系很简单，一个类只能有一个父类，易于管理程序，同时一个类可以实现多个接口(interface)，从而克服单继承的缺点。

继承所表达的就是一种对象类之间的相交关系，它使得某类对象可以继承另外一类对象的数据成员和成员方法。若类B继承类A，则属于B的对象便具有类A的全部或部分性质(数据属性)和功能(操作)，我们称被继承的类 A 为基类、父类或超类，而称继承类 B 为 A 的派生类或子类。

继承的定义

语法如下:

class 子类 extends 父类{}

有时，父类也称为超类(super class)，子类也称为派生类。

从理论上说，一个类可以是多个一般类的特殊类，它可以从多个一
般类中继承属性与方法，这便是多重继承。Java 出于安全性和可靠性的考虑，仅支持单重继承，而通过使用接口机制来实现多重继承。

继承的限制

子类可以继承父类的全部操作(属性、方法)，但是对于所有的公共操作是可以直接继承的，而所有的私有操作是无法直接继承的，而是通过其他的方式间接访问。

一个子类只能继承一个父类，属于单继承，而不能同时继承多个父类。

子类对象的实例化

final关键字

在 Java 中可以使用 final 关键字定义类、方法、属性:
· 使用final关键字定义的类不能有子类
· 使用final声明的方法不能被子类所覆写
· 使用final声明的变量即成为常量，常量必须在声明时给出具体的内容。

instanceof关键字

通过 instanceof 关键字可以判断某一个对象是否是某一个类的实例

包及访问控制权限

Java 项目的组织形式都是按照包进行组织的。如果在某包中用到另一个包定义的类，此时就需要使用 import 语句导入该类。

import 包.类 ;

在这里插入图片描述

代码块

概念是：在程序中使用“{}”括起来的一段代码就称为代码块，根据代码块出现的位置或声明的关键字的不同，分为四种：

· 普通代码块：在一个方法中定义的代码块，称为普通代码块
· 构造块：在一个类中定义的代码块
· 静态块：使用 static 关键字声明的代码块
· 同步代码块：留到线程再讲

本章小结

继承是继封装之后的面向对象特征。继承所表达的就是一种对象类之间的相交关系，它使得某类对象可以继承另外一类对象的数据成员和成员方法。

若类 B 继承类 A，则属于 B 的对象便具有类 A 的全部或部分性质(数据属性)和功能(操作)，我们称被继承的类 A 为基类、父类或超类，而称继承类 B 为 A 的派生类或子类。

与 C++相比，JAVA 只支持单继承，单继承使 JAVA 的继承关系很简单，一个类只能有一个父类，易于管理程序，同时一个类可以实现多个接口（interface），从而克服单继承的缺点。

异常的捕捉及处理

异常的处理流程

try{
	可能出现异常的语句 ;
} catch(异常类型 异常对象){
	处理异常 ；
} catch(异常类型 异常对象){
	处理异常 ；
} ...
finally{
	异常处理的统一出口 ; 
}

异常的处理中基本上都是采用如下的过程完成的：

1.每当一个异常产生之后，实际上都会自动生成一个异常类的实例化对象，如果此时编写了异常处理语句的话，则进行异常的处理，如果没有的话，则交给 JVM 进行处理。
2.使用了 try 捕获异常之后，将自动与 catch 中的异常类型相匹配，如果匹配成功，则表示可以使用此 catch 处理异常，如果都没有匹配成功的，则不能处理。
3.程序中不管是否出现了异常，如果存在了 finally 语句，都要执行 finally 语句的代码。
4.如果程序中没有 finally 语句，程序捕捉到了异常，直接进入对应的 catch语句进行处理，如果出现了异常，而程序没有定义相关的 catch，此时程序的异常交给JVM 处理，极有可能出现 JVM 无法处理的情况而导致崩溃。

异常程序的处理逻辑按照如下步骤进行：
· try 语句之中同时有多个 catch，每个 catch 处理一个具体的异常；
· 捕获范围小的异常要放在捕获范围大的异常之前；
· 无法识别的异常使用 Exception 这个超类的对象进行接收处理
· 最后利用 finally 进行统一的处理

throws 和 throw 关键字

throws 关键字主要是用在方法的声明上，表示一个方法不处理异常，而交给被调用处进行处理。

即在某个方法中没有处理，或者没有办法处理，这个时候用 throws 关键字抛出一个异常。

assert 关键字

抽象类接口与多态

抽象类、接口和多态是整个 JAVA 面向对象的核心部分，但是要想充分理解此概念，就必须结合对象多态性

抽象类

抽象类使用有以下原则：
· 抽象类不能直接实例化。
· 抽象类必须有子类，子类（如果不是抽象类）的话，则必须覆写抽象类中的全部抽象方法。
· 如果一个抽象类中没有任何一个抽象方法，依然是抽象类。

public abstract class Demo {
    public Demo(){
        System.out.println("抽象类中的构造方法" );
    }
    public void print(){
        System.out.println("Hello!");
    }
    public abstract void fun();
}
class DemoImpl extends Demo {
    public DemoImpl(){
        super();
        System.out.println("子类中的构造方法");
    }
    public void fun(){
    }
}
public class Main{
    public static void main(String args[]){
        DemoImpl demoimpl = new DemoImpl();
        demoimpl.print();
    }
}

运行结果：

抽象类中的构造方法
子类中的构造方法
Hello!

接口

当一个类中全部是由抽象方法和全局常量组成的时候，那么就可以将这个类定义成一个接口了

接口使用 interface 关键字声明。其定义格式如下所示：

interface Demo{ // 接口
	public static final String INFO = "hello world";
	public abstract void print();
	public abstract void fun();
}

一个接口定义完成之后，实际上与抽象类的使用原则是一样的：
· 接口必须有子类（实际上叫做实现类），子类（如果不是抽象类）则必须覆写接口中的全部抽象方法；
· 接口是不能直接进行对象的实例化操作。
· 一个子类可以同时继承（实现）多个接口。

这里忽略一部分，最后再删改

happyhwq

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java基础（二）

字符串String类对象实例化的两种方法及其优缺点String 在使用中有两种实例化的方法:一种是采用直接赋值(将字符串赋String的对象);第二种方法是通过构造方法完成实例化的操作，方法如下:方法名称描述public String(Stringoriginal)接收 String 对象，实例化 String 类采用直接赋值(将字符串赋String的对象)的...
复制链接

扫一扫