java复习-7

java复习-7

面向对象（oop）

面向对象的思想：物以类聚，分类的思想模式，线性思维

三大特性：封装，继承，多态

类和对象的创建

类的定义：
class 类名称{
属性名称;
返回值类型 方法名称(){}
}

使用new关键字创建对象

new 关键字表示创建一个对象
new 关键字表示实例化对象
new 关键字表示申请内存空间
注意：如果使用一个没有申请内存空间的对象，会报空指针异常：java.lang.NullPointerException

（1）new关键字：表示向内存申请空间，也表示实例化一个对象，创建一个对象。
（2）一个对象在内存中的大小，由该对象的所有属性所占的内存大小的总和。引用类型变量在32位系统上占4个字节，在64位系统上占8个字节。加上而外的对象隐性数据所占的大小。
（3）相同的类型才可以赋值
（4）不同的引用，指向同一个对象，任何一个引用改变对象的值，其它引用都会反映出来。
（5）编程时要注意的问题，在确定不使用对象时，要尽早释放对象：引用=null
（6）当一个堆中的对象没有被任何引用变量所指向时，该对象会被JVM 的 GC 程序认为是垃圾对象，从而被回收

构造方法

无参构造方法：
public Dog(){} //如果一个类没有定义构造方法，则默认无无参构造，如果有定义有参构造，最好再显示定义一个无参构造方法

带参构造方法：
public Dog(String name){
this.name = name;
}

多参构造方法：
public Dog(String name,int age){
this.name = name;
this.age = age;
}

（1）构造方法名称与类名相同，没有返回值声明（包括 void）
（2）构造方法用于初始化数据（属性）
（3）每一个类中都会有一个默认的无参的构造方法
（4）如果类中有显示的构造方法，那么默认构造方法将无效
（5）如果有显示的构造方法，还想保留默认构造 方法，需要显示的写出来。
（6）构造方法可以有多个，但参数不一样，称为构造方法的重载
（7）在构造方法中调用另一个构造方法，使用this(...)，该句代码必须在第一句。
（8）构造方法之间的调用，必须要有出口。
（9）给对象初始化数据可以使用构造方法或setter方法，通常情况下，两者都会保留。
（10）一个好的编程习惯是要保留默认的构造方法。（为了方便一些框架代码使用反射来创建对象）
（11）private Dog(){}，构造方法私有化，当我们的需求是为了 保正该类只有一个对象时（单例模式就是私有化构造器）。

this关键字

this关键字指向的是当前对象的引用
调用类中的属性：this.属性名称，指的是访问类中的成员变量，用来区分成员变量和局部变量（重名问题）
调用类中的方法：this.方法名称，用来访问本类的成员方法
调用类构造方法：this();访问本类的构造方法，()中可以有参数的 如果有参数 就是调用指定的有参构造
注意：
1.this() 不能使用在普通方法中，只能写在构造方法中
2.必须是构造方法中的第一条语句

static关键字

static关键字的作用：方便在没有创建对象的情况下来进行调用（方法/变量）。
a、使用static关键字修饰一个属性：声明为static的变量实质上就是全局变量
b、使用static关键字修饰一个方法：在一个类中定义一个方法为static，那就是说，无需本类的对象即可调用此方法（类调用）
c、使用static关键字修饰一个类（内部类）：
声明为static的方法有以下几条限制： 
它们仅能调用其他的static 方法，反过来是可以的。 
它们只能访问static数据。 
它们不能以任何方式引用this或super。
不允许用来修饰局部变量

继承

Java 的继承是单继承，但是可以多重继承

继承是面向对象三大特征之一
继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类

被继承的类称为父类（超类），继承父类的类称为子类（派生类）
通过继承可以实现代码重用
子类拥有父类非 private 的属性、方法。
子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
子类可以用自己的方式实现父类的方法。
构造器而言，它只能够被调用，而不能被继承，可以通过使用super()进行调用，
对于继承而已，子类会默认调用父类的构造器，但是如果没有默认的父类构造器，子类必须要显示的指定父类的构造器（通过super（）），而且必须是在子类构造器中做的第一件事(第一行代码)。
对于protected而言，它指明就类用户而言，他是private，但是对于任何继承与此类的子类而言或者其他任何位于同一个包的类而言，他却是可以访问的



语法：[访问权限] class 子类名 extends 父类名{
　　类体定义；
}

示例：
public class Dog{
private String name;
private String sex;
public void eat(){System.out.println(“吃饭”);}
}
public class HomeDog extends Dog{
　　//类的定义
}
public class HuskyDog extends Dog{
　　//类的定义
}

protected（受保护的访问权限修饰符，用于修饰属性和方法，使用protected修饰的属性和方法可以被子类继承）


（1）继承是发生在多个类之间
（2）继承使用关键字extends
（3）JAVA只能单继承，允许多层继承
（4）被继承的类叫父类（超类），继承父类的类叫子类（派生类）
（5）在父类中的非私有属性和方法可以被子类继承
（6）protected（受保护的访问权限修饰符），修饰的属性或方法可以被子类继承
（7）构造方法不能被继承
（8）创建对象会调用构造方法，调用构造方法不一定就是创建对象
（9）实例化子类对象，会先调用父类的构造方法，如果父类中没有默认的构造方法，那么子类必须显示的通过super(...)来调用父类的带参构造方法，super也只能在子类构造方法中的第一句

继承的好处：
a、提高代码的复用性
b、提高代码的维护性
c、让类与类之间产生关系，是多态的前提
继承的缺点：增强了类与类之间的耦合性

初始化顺序

父类静态字段初始化
父类静态代码块
子类静态字段初始化
子类静态代码块
父类普通字段初始化
父类构造代码块
父类构造函数
子类普通字段初始化
子类构造代码块
子类构造函数

super关键字

可以理解为对父类的引用，使用super来调用父类的属性，方法，和构造方法
super可以完成以下的操作：
a、使用super调用父类中的属性，可以从父类实例处获得信息。
b、使用super调用父类中的方法，可以委托父类对象帮助完成某件事情。
c、使用super调用父类中的构造方法（super(实参)形式），必须在子类构造方法的第一条语句，调用父类中相应的构造方法，若不显示的写出来，默认调用父类的无参构造方法，比如：super();

son s=new son();
s.jicheng();



public class father {

	public void syso() {
		System.out.println("我是你爸爸");

	}
}



public class son extends father {

	
	public void jicheng() {
		super.syso();
	}
	
}

抽象类

抽象类的基本概念
（1）很多具有相同特征和行为的对象可以抽象为一个类；很多具有相同特征和行为的类可以抽象为一个抽象类。
（2）使用abstract关键字声明的类为抽象类

定义一个抽象类

abstract class Animal{
　　public abstract void move();
}
abstract class Person extends Animal{
　　private String name;
　　//...
　　public abstract void eat();//抽象方法
}

抽象类的规则：
a、抽象类可以没有抽象方法，有抽象方法的类必须是抽象类
b、非抽象类继承抽象类必须实现所有抽象方法
c、抽象类可以继承抽象类，可以不实现父类抽象方法。
d、抽象类可以有方法实现和属性
e、抽象类不能被实例化
f、抽象类不能声明为final
g、抽象类可以有构造方法

接口

接口的定义格式：
interface 接口名称{
　　全局常量 ;
　　抽象方法 ;
}
示列：

interface IEat{
　　//public abstract void eat();
　　void eat(); //默认为public abstract void eat();
　　//public static final int NUM = 10;
　　int NUM = 10; }

interface ISleep extends IEat{
void sleep();
}

接口的使用规则：
（1）定义一个接口，使用interface关键字
（2）在一个接口中，只能定义常量、抽象方法，JDK1.8后可以定义默认的实现方法
（3）接口可以继承多个接口：extends xxx,xxx
（4）一个具体类实现接口使用implements关键字
（5）一个类可以实现多个接口
（6）抽象类实现接口可以不实现接口的方法
（7）在接口中定义的方法没有声明 访问修饰符，默认为public
（8）接口不能有构造方法
（9）接口不能被实例化
java8新增
（1）增加了default方法和static方法,这两种方法完全可以有方法体
（2）default方法属于实例,static方法属于类(接口)
（3）接口中的静态方法不会被继承,接口中的静态变量会被继承

public interface IUser {
　　static void say() {
　　System.out.println("say_" + IUser.class);
　}

　　default void eat() {
　　System.out.println("eat_" + IUser.class);
　}

内部类

内部类就是在一个类的内部定义的类。
成员内部类：内部类对象依赖外部类对象而存在，即在创建一个普通内部类对象时首先需要创建其外部类对象
内部类对象可以访问外部类对象中所有访问权限的字段，同时，外部类对象也可以通过内部类的对象引用来访问内部类中定义的所有访问权限的字段
成员内部类格式如下：

class Outer {
　　class Inner{}
}

编译上述代码会产生两个文件：
Outer.class和Outer$Inner.class。

编译上述代码会产生两个文件：
Outer.class和Outer$Inner.class。

在外部创建内部类对象
内部类除了可以在外部类中产生实例化对象，也可以在外部类的外部来实例化。
那么，根据内部类生成的*.class文件：OuterInner.class“Inner.class“” 符号在程序运行时将替换成“.”
所以内部类的访问：通过“外部类.内部类”的形式表示。

Outer out = new Outer() ;// 产生外部类实例
Outer.Inner in = null; // 声明内部类对象
in = out.new Inner() ; // 实例化内部类对象

局部内部类
内部类可以作为一个类的成员外，还可以把类放在方法内定义（不常用，匿名内部类可以显示局部内部类的功能）。
在局部内部类里面可以访问外部类对象的所有访问权限的字段，而外部类却不能访问局部内部类中定义的字段
注意：
a、局部内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。
b、局部内部类对象不能使用该内部类所在方法的非final局部变量。

class Outer {
　　public void doSomething(){
　　class Inner{
　　　　public void seeOuter(){}
　　}
　　}
}

静态内部类
在一个类内部定义一个静态内部类：
静态的含义是该内部类可以像其他静态成员一样，没有外部类对象时，也能够访问它。静态嵌套类仅能访问外部类的静态成员和方法。
静态内部类中也无法访问外部类的非静态成员

class Outer{
　　static class Inner{}
}
class Test {
　　public static void main(String[] args){
　　Outer.Inner n = new Outer.Inner();
}
}

匿名内部类
匿名内部类就是没有名字的内部类。
匿名内部类的三种情况：
（1）继承式的匿名内部类
（2）接口式的匿名内部类
（3）参数式的匿名内部类

在使用匿名内部类时，要记住以下几个原则：
（1）不能有构造方法，只能有一个实例。
（2）不能定义任何静态成员、静态方法。
（3）不能是public,protected,private,static。
（4）一定是在new的后面，用其隐含实现一个接口或继承一个类。
（5）匿名内部类为局部的，所以局部内部类的所有限制都对其生效

局部内部类访问局部变量必须用final修饰，为什么?
当调用这个方法时，局部变量如果没有用final修饰，他的生命周期和方法的生命周期是一样的，当方法被调用时会入栈，
方法结束后即弹栈，这个局部变量也会消失，那么如果局部内部类对象还没有马上消失想用这个局部变量，显然已无法使用了，
如果用final修饰会在类加载的时候进入常量池，即使方法弹栈，常量池的常量还在，也就可以继续使用了。

注意：在jdk1.8中取消了在局部内部类中使用的变量必须显示的使用final修饰，编译器默认会为这个变量加上final

内部类的作用
每个内部类都能独立地继承自一个（接口的）实现，所以无论外部类是否已经继承了某个（接口的）实现，对于内部类都没有影响。
如果没有内部类提供的可以继承多个具体的或抽象的类的能力，一些设计与编程问题就很难解决。从这个角度看，
内部类使得多重继承的解决方案变得完整。接口解决了部分问题，而内部类有效地实现了“多重继承”。

依赖外部类对象的：成员内部类，方法内部类，匿名内部类
静态内部类不依赖外部类的对象。所以，我们在项目中优先考虑选择静态内部类（不会产生内存泄露）