JAVA面向对象编程
目录
1.构造方法：
2.this
3.继承
4.父类
5.重写
6.重载
7.访问修饰符
8.单例的实现
9.修饰符：static,final,abstract
10.interface 接口
11.开闭原则：
12.内部类
特征：封装，继承，多态（，抽象）
1.构造方法：
构造器:
构造方法(构造函数)
1.构造器名称和类名一致
2.没有返回值类型(8种基本类型,String,引用类型,void)
3.一个类中可以有多个构造器,多个构造器靠参数列表(个数,顺序,类型)来区分
4.构造器的调用:当类被实例化时调用(new)--通过（名+参数列表）调用
5.如果你不给这个类提供构造器，JVM会给该类提供一个默认的无参的构造器
如果你给这个类提供构造器，JVM不会给该类提供一个默认的无参的构造器
作用:
为了初始化对象方便,更合理的初始化对
2.this
this:当前类对象
1. this.
当前类的属性和当前类的方法
2. this()
当前的构造器，只能写在构造器的第一句
3.继承
1 .A is B(A是B)
2.关系是相对的
3.java中只支持单继承
4.父类
super:父类的对象
1. super.
能调用父类的属性和父类的方法
2. super()
调用父类的构造--通过参数列表
只能写在构造器的第一句
5.重写
重写:
1.存在继承关系的两个类中方法
2.方法的名称一样，参数列表一样，返回类型也一样
6.重载
在同一个类中的多个方法,方法的名称相同，参数列表不相同,返回类型无所谓
7.访问修饰符
1）、public， private， protected，默认都可修饰成员变量，成员方法。
2）、public,默认 可修饰顶层类。
3）、局部变量不能用访问修饰符。
4）成员变量或成员方法的访问控制：
| 位置 |
private |
默认 |
protected |
public |
| 同一个类 |
是 |
是 |
是 |
是 |
| 同一个包内的类 |
否 |
是 |
是 |
是 |
| 不同包内的子类 |
否 |
否 |
是 |
是 |
| 不同包并且不是子类 |
否 |
否 |
否 |
是 |
8.单例的实现
单例：实例化出来的对象是同一个对象
方法：写一个私有的，静态的构造
1、通过静态方法实现
代码：
Public class Run{
private static Run r=null;
public static Run gerRun(){
if(r==null){
r=new Run();
}
Return r;
}
}
Public class Transfer{
Public static void main(String[] args){
Run ru=Run.getRun();
Sysetem.out.printlin(ru);
Run ru1=Run.getRun();
Sysetem.out.printlin(ru1);
}
}运行结果：
Run @4554617c
Run @4554617c
2、通过静态块实现
public class demo02 {
private static demo02 d=null;
static {
if(d==null){
d=new demo02();
}
}
public static demo02 getdemo02(){
return d;
}
public class demo01 {
public static void main(String[] args) {
demo02 d1=demo02.getdemo02();
System.out.println(d1);
demo02 d2=demo02.getdemo02();
System.out.println(d2);
}
}运行结果：Run @4554617c
Run @4554617c
9.修饰符：static,final,abstract
（一）static-静态
1.static能修饰属性，方法，静态块
2.static修饰的属性:是多个对象共有的一块空间
3.static修饰属性，方法--可以不通过实例化对象得到，可以通过类名直接调用
4.静态方法和静态块中只允许使用静态属性
5.静态块是在类被加载时调用
（二）final:常量
1.final能修饰变量,方法,类
2.final修饰变量:不能被第二次赋值
3.final修饰方法:不能被重写
4.final修饰类:不能被继承
（三）abstract ：抽象类
1.用abstract 修饰的类就是抽象类
2.抽象类中可以有属性，方法，还可以有抽象方法
抽象方法：
A.用abstract 修饰的方法就是抽象方法
B.抽象方法只有方法的声明，没有方法的实现（没有{}）
3.抽象类不能实例化（new）
4.使用： 用一个类去继承抽象类，并把这个抽象类中的所有抽象方法都“重写“，否则该类还是为抽象类
5.可以有构造方法，只是不能实例化
代码示例：
//通过父类声明，子类实例化来使用这个抽象类
public class Test{
public static void main(String[] args){
Person p=new Person_C();
p.say();
System.out.println(p.i);
}
}
//由于抽象类不能实例化，通过继承实现抽象类，将所有抽象方法重写
public class Person_C extends Person{
public void say(){
System.out.println("你好");
}
}
//抽象类，可以有属性，方法，抽象方法
public abstract class Person{
public int i=1;
public abstract void say();
}
10.interface 接口
1.用interface修饰的东西就是接口
2.接口中可以有属性
接口中默认的属性类型为public static final类型（可省略）
3.接口中只能有方法的声明（或者抽象方法），不能有方法的实现
4.接口不能被实例化
5.用一个类去“实现”一个接口，实现的关键字是implements
实现接口时必须把所有的方法声明都实现，否则该类是一个抽象类
6.一个类可以实现多个接口，A extends B implements C,D,E
7.接口允许多继承
代码示例：
//用iterface修饰的就是接口
public interface Tools1{
float G=9.8f;
//public static final float G=9.8;接口中的属性默认为public static final类型，可以省略
//接口中可以有方法的声明（或者抽象方法），不能有方法的实现
public void usb();
//接口中不能有构造方法
}public interface Tools2{
float PI=3.141592653f;
public void circle(int r);
}实现方式一：
//用一个类去“实现”接口需要有implement关键字,接口可以多继承
public class PC implement Tools1,Tools2{
//要对接口中的所有方法实现重写，否则该类是一个抽象类
@override
public void usb(){
System.out.println("PC's usb.")
}
@override
public void circle(int a){
System.out.println(2*a*PI);
}
}实现方式二：
//一个类可以实现多个接口
public class Test1 extends Demo implements Tools1,Tools2{
public static void main(String[] args) {
Test1 t=new Test1();
t.circle(15);
t.usb();
}
@Override
public void usb() {
System.out.println("usb()");
}
@Override
public void circle(int r) {
System.out.println(2*r*PI);
}
}
补充：满足继承关系的时候使用抽象类，不满足抽象关系的时候使用接口，但是我们日常工作中都使用的是接口。
11.开闭原则：
对扩展（继承，接口）开发，对修改关闭
12.内部类
代码示例：
public class A {
int a=10;
// 内部类的实例化：内部类不能直接被实例化，在外部类实例化一个内部类对象
public B bbb=new B();
public void say(){
System.out.println("...A...say()...");
}
class B{
int b=100;
public void say(){
System.out.println("...B...say()...");
}
}
}public class Test {
public static void main(String[] args) {
A aaa=new A();
// 内部类的调用
aaa.bbb.say();
System.out.println(aaa.bbb.b);
}
}父类声明，子类实例化的特点：
对象是父类的对象，能调用父类的属性和方法，也能调用子类重写父类的方法