第三周学习
java第三周总结
第三周主要学的是关于面向对象的知识，主要的知识的围绕着继承，封装，多态来学习的，知道并且理解其中的特点还有联系，如何运用。
继承
- 继承使用extends关键字
- 继承的类被称为子类，被继承的类被称为父类（或者超类）
- 子类继承父类之后，子类直接使用父类中的非私有的元素，并且子类中也能定义自己的元素
- 一个类只能继承一个父类
- 继承关系的构造中，创建子类对象时先调用父类的构造器
- java中允许多重继承
例如-----
先设置一个父类
package CCCC;
public class A1 {
public String name;
public int age;
public void coding() {
System.out.println(name + "超级会写代码");
}
public void love(){
System.out.println("情场高手!!!!");
}
}
创建子类
package CCCC;
public class A2 extends A1{
public static void main(String[] args) {
A1 s = new A1();
s.name = "刘德华";
s.coding();
s.love();
}
}
运行结果
继承注意事项
- 子类只能继承父类的属性和方法，不能继承构造器
- 子类对象构造之前会先执行父类的构造器（如果存在多重继承，则从最顶层父类构造器开始执行）
- 一个父类可以存在多个子类，但是一个子类只能存在一个父类
- Java不允许多继承，但是支持多重继承
- 被protected修饰的元素可以在子类中被访问（即便父类和子类不在同一个包）
重写
-当父类终端方法实现满足不了子类需求时，此时子类中可以编写一个与父类方法一模一样的方法，对父类的方法进行覆盖，该过程称之为方法的重写（Override）
案列：
package CCCC;
public class A1 {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//动物咆哮（不同的动物发出的叫声一样，因此无法一概而论）
public void bark() {
System.out.println(name + "哇哇哇哇啊啊...");
}
}
package CCCC;
public class A2 extends A1{
//对bark方法重写
public void bark() {
System.out.println(getName() + "汪汪汪。。。");
}
}
package CCCC;
public class A3 extends A1{
//对bark方法重写
public void bark() {
System.out.println(getName() + "喵喵喵。。。");
}
}
package CCCC;
public class A4 {
public static void main(String[] args) {
A3 cat = new A3();
cat.setName("加菲猫");
A2 dog = new A2();
dog.setName("拉布拉多");
cat.bark();
dog.bark();
}
}
方法重写注意事项：
- 重写必须存在继承关系，一般是由子类重写父类方法
- 被重写的方法名称，返回值类型，参数列表必须跟父类方法一模一样
- 子类重写的方法访问权限不能低于父类
重载
重载指的是在同一个类中，或者存在继承关系的多个类中，存在同名的方法，这些方法的名称一模一样，但是方法的参数个数 ，类型，顺序任意有一项不一致，具备以上特点的方法统一称之为重载方法。
重载的条件:
- 方法名称必须一致
- 参数的个数、顺序和类型任意有一项不一致
- 重载与返回值无关
案列：
System.out.println("helloworld");
System.out.println(10);
System.out.println(true);
System.out.println('a');
System.out.println(3.14);
多态
多态是面向对象程序设计中最为重要的一种(没有之一)特性，java中的多态主要包含两种呈现方式：
- 行为的多态(方法多态：一种方法以多种不同的形态呈现)
- 方法的重写
- 方法的重载
- 变量的多态
- 父类的引用指向子类对象
- 子类引用指向父类对象(强制转换：前提是被转换的引用变量原本指向的就是目标对象)
package CCCC;
public class A1 {
public void eat(){
System.out.println("宠物吃东西");
}
}
package CCCC;
public class A2 extends A1{
}
package CCCC;
public class A3{
public static void main(String[] args){
//父类引用指向子类对象(p只能调用父类和子类共有的方法)
A1 p = new A1();
//子类引用指向父类对象（实际还是Dog对象）
A2 d = (A2) p;
}
}
多态的好处
多态性的优势体现在如下：
- 提高程序的可扩展性
- 提高代码的可复用性
- 提高了程序的可维护性
封装类型
由于java中提供基本数据类型只能用于一些简单运算(算术，关系，布尔逻辑等)，但是无法像引用数据类型一样可以进行对象创建，方法或属性调用；因此对于一些特殊需求(比如：将字符串类型的数字转换整数，将十进制整数转成其他进制：2进制，8进制，16进制)，基本数据类型显得功能不足；所以JDK提供了针对以上需求的基本类型封装类，用于进行相关类型的面向对象操作(方法调用)。
针对java中的8个基本类型数据，JDK也提供了对应的8个封装类型：
| 基本类型 | 封装类型 |
|---|---|
| byte | java.lang.Byte |
| short | java.lang.Short |
| int | java.lang.Integer |
| long | java.lang.Long |
| float | java.lang.Float |
| double | java.lang.Double |
| char | java.lang.Character |
| boolean | java.lang.Boolean |
基本使用
int i = 10;
int j = 20;
//需求:
//将十进制整数类型转成二进制字符串 1010
//将字符串转成整数型
// int ---> java.lang.Integer
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);
Integer inte = new Integer("123");
System.out.println(inte + i);
装箱拆箱
在JDK1.5之后，引入了装箱和拆箱机制，用于实现基本类型数据和对应的封装类型之间的自动转换。
- 装箱(boxing)：将基本类型的数据值包装为对应的引用类型对象
- 拆箱(unboxing)：将封装类型中的基本数据值拆成为基本数据类型
//装箱（boxing）
Integer i = 10;
//拆箱(unboxing)
int j = new Integer(10);
装箱和拆箱机制的实现：
1.5之后编译器对以下代码自动调用Integer.valueOf()完成装箱提供能
Integer i = 10
拆箱的实现使用的是如下方法
intValue()
String类
String是来自java.lang包中的一个常见字符串处理类，用于表示一个定长字符串，String的底层实现原理实际上就是一个字符序列(char数组)；由于String是一个长度不可变的字符数组，因此对String进行修改实际就是在创建新的对象，在进行大量字符串拼接操作时内存和时间的开销会比较大，影响程序执行效率，因此String不适合做大量的字符串拼接操作。（如果有大量字符串拼接需求，建议使用:StringBuffer或StringBuilder）。
常见构造器
| 构造器 | 说明 |
|---|---|
| String(String s) | 根据提供的字符串直接量创建String对象 |
| String(char[] c) | 根据提供的字符数组创建String对象 |
| String(char[] c,int offset,int len) | 根据提供的字符数组，偏移量以及长度构建String对象 |
| String(byte[] b) | 根据提供的字节数组，转换为String对象 |
| String(byte[] b,int offset,int len) | 根据提供的字节数组，偏移量以及长度构建String对象 |
抽象类（abstract class）
java中凡是普通类都具备实例化对象的能力，因为一个类具备了实例化对象的一些必要信息，比如属性，比如行为；但是有些时候，当一个类中信息不足以描述一个具体对象时，此时该类就应该考虑定义为抽象类。
java中的抽象类中所包含的信息，不足以描述一个具体对象，抽象类的内部成分由以下信息构成:
- 属性
- 构造器
- 行为
- 已实现
- 未实现（抽象方法）
抽象类基本案例
语法
public abstract class 类名称{
//属性定义
//方法定义
//抽象方法定义
public abstract 返回值类型 方法名(参数列表);
}
案例:
/**
* 抽象类
* @author mrchai
*/
public abstract class Animal {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//抽象方法
public abstract void eat();
public abstract void sleep();
}
Dog类:
public class Dog extends Animal{
//实现方法
public void eat() {
System.out.println("吃骨头");
}
//实现方法
public void sleep() {
System.out.println("睡狗屋");
}
}
特点
- 抽象类必须使用abstract修饰
- 抽象类存在构造器，但是无法实例化（可以使用匿名内部类创建子类对象）
- 抽象类中通常会包含抽象方法
- 抽象类的存在一般是需要由子类继承，子类一旦继承了抽象类，则子类必须实现父类中的抽象方法（除非子类也是抽象类）
- 抽象类允许继承其他抽象类，但是也只能单继承，可以通过多重继承的方式实现多继承
- abstract只能修饰类和方法
上一篇： 图片标注插件