Java学习笔记——初级篇:Java SE(四)面向对象(上)
四、面向对象(上)
01.基本概念:
- 面向对象是一种编程思想,一种思考问题的思维方式;
- 建立面向对象思维方式:
2.1 先整体,再局部;
2.2 先抽象,再具体; - 对比:
3.1 面向过程:以步骤为单位,一步一步完成某个具体事情;
3.2 面向对象:以对象为单位,通过调度组合不同的对象来完成某件事。
02.类和对象
- 类:分类、类别,通过分类,区分不同的事物种类;所以类是一组具有相同特性(属性)与行为(方法)的事物的集合;
- 类和对象的关系:
2.1 类表示一个共性的产物,是一个综合的特征;
2.2 对象是一个个性的产物,是一个个体的特征;
2.3 类由属性和方法组成,属性就相当于一个个的特征,方法就相当于一个个的行为; - 定义方式:
3.1 class+类名称{ },类名称 对象名称=new 类名称();
3.2 一个类想要真正的进行操作,则必须依靠对象;
3.3 访问类中的属性和方法:对象.属性,对象.方法();
3.4 class Horse{Horse h=new Horse();h.run();new Horse.eat()(匿名对象);}
3.5 匿名对象:只能使用一次,用完后,该对象就会被释放;
3.6 释放对象:h=null,堆内存中的对象没有栈中的引用指向时,会被GC回收。 - 小结:
03.封装性
- 概念:隐藏实现细节,仅对外提供访问接口;
- 优点:
2.1 模块化;
2.2 信息隐藏;
2.3 代码重用;
2.4 插件化易于调试;
2.5 具有安全性; - 缺点:影响程序执行效率;
- 实现:private关键字修饰属性和方法,提供public共有的方法间接访问;
- 成员变量和局部变量:
5.1 类中的位置不同: 成员变量书在类中定义的变量,局部变量是在方法中定义的变量;
5.2 内存中的位置不同:成员变量属于对象,进堆内存;局部变量属于方法,进栈内存;
5.3 生命周期不同:成员变量随着对象的创建而存在,随着对象的销毁而消失;局部变量随着方法的调用而存在,方法调用完毕消失;
5.4 初始化值不同:成员变量有默认初始化值,引用类型默认为null;局部变量没有默认初始化值,必须定义、赋值。
04.构造方法
- 定义:类构造对象时调用的方法,用于对象的初始化,是实例化(new创建)一个类的对象最先调用的方法;
- 定义格式:方法名称与类名称相同,无返回值类型;
- 构造方法重载:无参构造方法、带参构造方法;
- 小结:
- this关键字:
5.1 调用类中的属性;
5.2 调用类中的方法或构造方法;
5.3 表示当前对象; - 值传递与引用传递:
/**
示例一:值传递
*/
public class Test1 {
public static void main(String[] args) {
int x=10;
method(x);
//基本数据类型直接赋值,跟堆没关系,输出仍然是10
System.out.println("x="+x);
}
public static void method(int mx) {
mx=20;
}
}
/**
示例二:引用传递
*/
public class Test2 {
public static void main(String[] args) {
int x=10;
Duck d=new Duck();
method(d);
//duck,d都存的一样的内存地址,都指向同一个堆内存对象,修改了age的值
System.out.println("Duck age="+d.age);
}
public static void method(Duck duck) {
duck.age=5;
}
class Duck{
int age=2;
}
}
- static关键字:
7.1 修饰属性,实质上就是全局变量;
7.2 修饰方法,无需本类的对象即可调用此方法;
7.3 修饰一个类(内部类); - 声明static方法限制:
8.1 仅能调用其他static方法;
8.2 只能访问static数据;
8.3 不能以任何方式引用this或super。
05.代码块
- 普通代码块:直接写在方法中的代码块;
public class Test {
public static void test() {
{//普通代码块,限制作用域
int i=10;
System.out.println(i);
}
}
}
- 构造块:在类中定义的代码块,在创建对象时被调用,优于构造方法执行;
public class Test {
{//构造块
System.out.println("构造块");
}
}
- 静态代码块:在类中使用static声明的代码块,在第一次创建对象时被调用,只会执行一次,优于构造块执行,一般用来初始化只调用一次的数据;
public class Test {
static{
System.out.println("静态代码块");
}
}
- 同步代码块:多线程时讲解;
- 重点:使用的顺序:静态代码块、普通代码块、同步代码块、构造代码块。
06.单例设计模式
- 保证一个类仅有一个实例,并提供一个访问它的全局访问点;
1.1 构造方法私有化;
1.2 声明一个本类对象;
1.3 给外部提供一个静态方法获取对象的实例; - 两种实现方式:
2.1 饿汉式:在类被加载后,对象被创建;
2.2 懒汉式:在第一次调用get方法时,对象被创建;
/**
1.饿汉式:占用内存时间长,提高效率
*/
public class Singleton1 {
private Singleton1() {};
private static Singleton1 s = new Singleton1();
public static Singleton1 getInstance {
return s;
}
}
/**
2.懒汉式:占用内存时间短,效率稍低
*/
public class Singleton2 {
private Singleton2() {};
private static Singleton2 s;
public static Singleton2 getInstance {
if(s==null){
s=new Singleton2();
}
return s;
}
}
- 优点:
3.1 在设计一些工具类的时候使用单例设计模式(通常工具类,只有功能方法,没有属性);
3.2 工具类可能被频繁调用;
3.3 节省重复创建对象所带来的内存消耗,提高效率;
07.对象数组案例
对象数组与管理:使用对象数组实现多个Chicken的管理;
// 需要管理的对象
public class Chicken {
private int id;
private String name;
private int age;
public Chicken() {}
public Chicken(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void print() {
System.out.println("Chicken [id=" + id + ", name=" + name + ", age=" + age + "]");
}
}
// 对象数组管理
import java.util.Arrays;
public class ChickenManager {
private Chicken[] cs = null;
private int count = 0;
public ChickenManager(int size) {
if (size > 0) {
cs = new Chicken[size];
} else {
cs = new Chicken[5];
}
}
// 实现动态数组
// 添加
public void add(Chicken c) {
if (count >= cs.length) {
int newLength = cs.length * 2;
cs = Arrays.copyOf(cs, newLength);
}
cs[count] = c;
count++;
}
// 删除
public void delete(int id) {
for (int i = 0; i < count; i++) {
if (cs[i].getId() == id) {
for (int j = i; j < count - 1; j++) {
cs[j] = cs[j + 1];
}
cs[count - 1] = null;
count--;
break;
}
}
}
// 更新
public void update(Chicken c) {
Chicken temp = find(c.getId());
if (temp != null) {
temp.setName(c.getName());
temp.setAge(c.getAge());
}
}
// 查找
public Chicken find(int id) {
for (int i = 0; i < count; i++) {
if (cs[i].getId() == id) {
return cs[i];
}
}
return null;
}
public void printAll() {
for (int i = 0; i < count; i++) {
cs[i].print();
}
}
public int length() {
return cs.length;
}
}
//测试
public class ChickenTest {
public static void main(String[] args) {
ChickenManager cm = new ChickenManager(5);
//动态数组,可添加超过原始数组长度
cm.add(new Chicken(1,"小小",10));
cm.add(new Chicken(2,"小一",2));
cm.add(new Chicken(3,"小二",8));
cm.add(new Chicken(4,"小三",6));
cm.add(new Chicken(5,"小四",12));
cm.add(new Chicken(6,"小五",5));
cm.add(new Chicken(7,"小六",4));
//打印所有
System.out.println("-----打印所有-------");
cm.printAll();
//查找
System.out.println("-----查找-------");
cm.find(3).print();
//更新
cm.update(new Chicken(1,"下蛋公鸡",9));
System.out.println("-----更新打印-------");
cm.printAll();
//删除
cm.delete(3);
System.out.println("-----删除打印-------");
cm.printAll();
cm.find(1).print();
System.out.println(cm.length());
}
}