java面向对象

1 面向对象编程： 

->类和对象

->属性

->方法

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

->接口

->设计模式

2 面层过程强调的是功能和行为。

3 面向对象强调的是具有功能的对象，重点是对象。

面向对象的思维方式更符合自然规律，每个事物都是对象，比如说：人（张某某），老虎（华南虎），飞机（737），比如：张某某.吃（西瓜）。

4 看到以上的写法，可以感受出来类 和 对象的区别

类是对象的模板，对象是类的实例。

5 1）创建类的时候，首字母要大写

2）一个类只能有一个public，不过只要有public，那么这个类名必须和文件名相同

3）其实最好 每个类都给他一个单独的文件，不论它有没有public

4）类包含Field 和Method

6 修饰符 关于权限的四个 public protected 默认 private 

public 可以被所有的访问

protected 可以被子类访问

默认的是包权限

private 则只可以让本类的内部访问

7 关于引用

比如这里有一个Person{}类

Person p = new Person（）;

p 是这个对象的引用 我们根据这个引用去对 new出来的对象进行操作，p不是对象，对象是后面new出来的

内存结构类似于数组里面的

前半句的时候 在栈内存中 创造了p引用，

后半句的时候 p指向了Person类创造出来的对象，其中这个对象里面的属性null 等待以后的赋值

8 关于Field

成员变量

局部变量

相同点：1 定义的格式都相同

2 都定义在大括号内 一个是类的括号 一个是局部方法的括号

不同点：1 成员变量前面要加修饰符 因为别的类要调用这个类里面的属性或者方法的时候，需要判断权限是否可以访问，一般成员变量的访问权限都是private的，这样可以满足java的封装的特性，而因为局部变量只在方法里面使用，方法是有修饰的，所以用不着把局部变量再修饰一遍。

2 在内存中的位置不同来，成员变量在堆上，局部变量是在栈上，引用也在栈上，形参也是局部变量

3 初始值，对于成员变量，设不设初始值都无所谓，因为在创建对象的时候，成员变量因为在堆上，所以如果有初始值则直接加载初始值，如果没有初始值的话，那么类会自动赋值上默认值。但是局部变量，如果有计算的话，那么就要设置初始值，如果不计算的话，仅仅是当做一个中间的用来作传递作用的，那么可以不设置初始值，如果参加了计算等，那么则要在定义的时候给予一个初始值。

9 方法的重载

方法的重载，主要注意的就是：方法名要相同，参数不同（包括个数，顺序，类型）

但是方法的返回值并无所谓。

10 匿名对象

直接new了就用就可以了，一般适用于只调用一次这个类或者类的方法的情形。

11 方法的传参

要注意传的参数是形参还是实参，对这个参数进行改变到底能不能达到自己期望的效果

12 封装

1 为了保护Filed的合法性 系统稳定等考究，所以有了封装，通常来说，封装可以更好的保护这个类的filed不被随意篡改，通过把field改成private，然后通过public方法来调用其中的属性，这种模式非常好。

2 有时候不仅仅是保护一个Field 还可以保护方法，保护构造方法等等。

3 就这样。getset方法

13 构造方法

构造方法不能写返回值类型，但是虽然不写返回值，其实它返回了一个对象~

构造方法也可以重载

构造方法如果不写的话，会自动调用一个默认的无参的构造器

14 this 表示的是这个对象，对象，对象，不是这个类。

即使是在继承中。this.方法 调用的

this还可以用语构造器

15 import 

为了使用不同包中的类，需要用到import

import 包名.子包名.类名|*

16 几个关键包

lang 包含一些java语言的核心类：比如String Math Integer System Thread 这个包是自动导入的

net 网络编程

io 输入输出

util 常用工具类

17 方法运行中如果用到了别的方法，大概是这么个类型

M

W

18 小心java.lang.NullPointerException

一个对象要是是null，那么它无法调用别的方法

19 继承 extends

注意的是，继承没法直接继承父类的构造器，但是子类的构造器用super来用父类的

子类不能访问父类私有的Field和方法

子类可以有自己独特的方法和Filed

父类想暴露给子类的field或者method 要用public或者protected

子类重写了父类的方法，还可以用super 来访问父类的方法

子类的访问权限不能比父类更严格

子类的抛出异常也不能大于父类

子类和父类必须同为static

20 super

子类是父类的扩展extends

创造子类的时候先创造父类

子类在继承父类的构造方法的时候

想加东西也是可以的

public A（double r ， int i）{

super（r）；

this.i = i；

}

21 用自动生成的时候，鼠标的光标记得放对位置

22 多态

简单的说 分为向上转型和向下转型
向上转型：Father father = new Son（）；
向下转型：Son s = （Son）father；

对于向上转型来说 father其实用的是son的方法，表现为son的特性，但是不能使用son里面的独特的方法
如果想用，则要把father再向下转型。转了之后 s 可以使用son的独有的方法

好处： 一个父类Person 有三个子类teacher，student，solid，如果要写一个方法，比如dosleep
 public static void dosleep（Person p）{
p.sleep（）；

}

否则 要写出三个 dosleep方法 以满足三个不同的子类，但是如果子类有上百个呢 这个时候就体现出来了。

可以在调用dosleep（）的时候 传参是Person的随意子类，而结果也是子类的sleep方法

23 instanceof 用来判断 前者是否是后者这个类型

适用于同上的情况 比如： p instanceof Student  返回的是一个布尔类型 判断p这个参数是否是Person 中其子类Student

24 == 和 equals

对于==号    

1 基础数据类型：判断值是否相等

2引用数据类型：判断存放的地址是否相等 如果相等 就是同一个事物

对于equals 

1 基本数据类型：直接用==号就可以了 用不着equals

2 引用数据类型 ：

1 Object类型（所有对象类型的父类）
    源码如下：

 

public boolean equals(Object obj) {  return (this == obj);}

2 String类型 他的equals 方法重写了 重写了如下 ：

public boolean equals(Object anObject) {        if (this == anObject) {            return true;        }        if (anObject instanceof String) {            String anotherString = (String)anObject;            int n = value.length;            if (n == anotherString.value.length) {                char v1[] = value;                char v2[] = anotherString.value;                int i = 0;                while (n-- != 0) {                    if (v1[i] != v2[i])                        return false;                    i++;                }                return true;            }        }        return false;    }

 所以总结就是 equals 方法中 ：

对于对象 是比较地址

对于String 是比较值

而String 有常量池 可以确定的String 是放在常量池里面的 所以是相等的

String s = "123";String s1 = "1";String s2 = "23";String s3 = "1"+"23";String s4 = s1+s2;String s5 = new String("123");System.out.println(s==s3);System.out.println(s==s4);System.out.println(s==s5);System.out.println(s.equals(s3));System.out.println(s.equals(s4));System.out.println(s.equals(s5));

结果： true

false

false

true

true

true

以后有需要 我们可以重写object里面的equals方法

多数时候自定义的类的对象是为了判断值 而不是判断地址

有自动生成的方法

下面是String 的内存分布：

String s1 = "abcd";

String s2 = "abcd";

String s3 = new String("abcd");

System.out.println(s1==s2);

System.out.println(s1==s3);

System.out.println(s1.equals(s3));

25 static 类变量 

1 static变量是属于类的，这个类的对象共用一个属性

2 当一个对象修改类变量时，其他对象会受到影响

3 可以通过 类.属性 或者 对象.属性 来调用。

4 内存中 satatic 变量 存在静态区 如上图

5 随着类加载而加载 不会随着对象消失而消失

类方法

1 通过类.方法 

2 类方法中不能使用普通成员变量的方法和属性 包括this和super

3 普通的方法和Field 可以调用static的属性和方法

PS  编写类的时候 随着对象生成而改变的量 比如自动生成的id 。计数器。可以用到

26 设计模式 单例 只生成一个对象

饿汉式

public class Single {private static Single s = new Single();private Single() {}public static Single getInstance() {//staticreturn s;}}

懒汉式 可能会出现并发的问题

public class Single2 {private static Single2 s2;private Single2() {// TODO Auto-generated constructor stub}public static Single2 getInstance() {if (s2==null) {s2 = new Single2();}return s2;}}

各有优缺点 

当一个类只能有一个实例，并且客户可以从一个众所周知的访问点访问它的时候。

当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。

懒汉获取对象较慢，但是加载对象快

饿汉获取对象较快，但是加载对象慢。

如果经常用到 可以用饿汉

偶尔用到 可以用懒汉

27 final

可以修饰 类 属性 方法

类：不能被继承

field ： 变成一个常量，且要显示初始化

方法：不能重写

28 abstract

抽象类
abstract 修饰一个类的时候 它就是抽象类
抽象类不能创建对象 不能实例化
没有方法体
如果一个类中存在抽象方法 那么这个类要定义成抽象类
反之则不成立
用来被继承
如果子类需要被实例化 那么子类要实现抽象类里面的所有的抽象方法
如果子类不实现所有的抽象方法，那么它也是个抽象类
不能修饰私有方法 构造方法 静态方法

29 接口

（web中比较多，se里面比较少）

一种规范。比如：和数据库通信等 地方会用到接口 mysql和oracle

一个类可以 实现多个接口

可以配合着继承，从本质上讲 接口就是一种特殊的抽象。