网站添加视频代码,电商网站开发脑图,logo素材大图,想开发一个app需要多少钱文章目录 什么是面向对象面向对象和面向过程区别创建一个对象用什么运算符?面向对象实现伪代码面向对象三大特征类和对象的关系。 基础案例代码实现实例化创建car对象时car引用的内存图对象调用方法过程 成员变量和局部变量作用范围在内存中的位置 关于对象的引用关系简介相关… 文章目录 什么是面向对象面向对象和面向过程区别创建一个对象用什么运算符?面向对象实现伪代码面向对象三大特征类和对象的关系。 基础案例代码实现实例化创建car对象时car引用的内存图对象调用方法过程 成员变量和局部变量作用范围在内存中的位置 关于对象的引用关系简介相关代码内存图解对象相等和引用相等的区别类的构造方法的作用是什么构造方法的特点深拷贝和浅拷贝区别浅拷贝深拷贝 匿名对象实例代码匿名对象与实例对象的区别实例代码图解匿名与非匿名内存运行 使用场景 封装什么是封装什么时private修饰代码示例 构造函数什么是构造函数构造函数的小细节构造代码块构造代码块示例以及与构造方法的区别 this关键字什么是this关键字this的应用解决构造函数初始化的问题用于构造函数之间进行互相调用 static关键字什么是static关键字static特点实例变量和类变量的区别静态使用注意事项静态有利有弊利处弊处 错误代码示范图解对象如何调用static变量 main函数主函数主函数的定义格式以及关键字含义主函数是固定格式的如何使用args 静态代码块格式 设计优化单例模式简介饿汉式懒汉式(线程不安全)懒汉式(线程安全)内部类模式双重锁校验(线程安全)枚举单例模式(线程安全) 相关面试题参考文献 什么是面向对象
面向对象和面向过程区别
面向过程:面向过程是将解决问题的思路转为一个个方法。 面向对象:面向对象则是编写一个对象将这些思路封装成一个个对象方法后续调用这个对象解决问题相对面向过程而言这种思路更符合人的思维并且更易扩展、复用、维护。
面向对象和面向过程性能差距:人们常常认为面向过程性能高于面向对象因为创建的对象开销远远大于面向过程实际上Java面向对象性能差的原因并不是这个真正的原因是Java为半编译语言运行并不是直接拿着二进制机械码执行而是需要结果字节码转换这一步。 而且面向过程的性能并不一定比面向过程快面向过程也需要计算偏移量以及某些脚本语言的性能也一定比Java好。
创建一个对象用什么运算符?
用new运算符创建的对象的实例会在堆内存中开辟一个空间。而引用则在栈内存中指向对象实例。
面向对象实现伪代码
以人开门为例人需要开门所以我们需要创建一个门对象描述门的特征这个门可以开或者关。所以门的伪代码如下:
门{开(){操作门轴}
}上文说到了面向对象的特点就是符合人的思维而人开门这个功能我们就可以创建一个人的对象编写一个开门的动作把门打开。通过这种对象调用对象的方式完成了功能。后续我们需要狗开门猫开门也只是编写一个方法调用门对象的开的动作。 人 {开门(门对象){门.打()}}
面向对象三大特征
封装继承多态
类和对象的关系。
以生活事务为例现实生活中的对象张三 李四。他们都有姓名、性别、学习Java的能力。
所以我们要想通过面向对象思想实现抽象出对象就得提取共性编写一个类有姓名、性别、学习Java的能力。
public class Student {private String name;private int sex;public void studyJava(){System.out.println(this.name学习java);}
}描述时这些对象的共性有姓名年龄性别学习java功能。再将这些分析映射到java中就是以class定义的类进行展开。
public static void main(String[] args) {Student zhangsannew Student();zhangsan.setName(张三);zhangsan.studyJava();Student lisinew Student();lisi.setName(李四);lisi.studyJava();// 输出结果
// 张三学习java
// 李四学习java}而具体对象就是对应java在堆内存中用new建立实体。
基础案例
需求描述汽车(颜色轮胎数)。描述事物其实就是在描述事物的属性和行为。
属性对应在类中即变量行为对应的类中的函数(方法)。
代码实现
public class Car {//描述颜色String color 红色;//描述轮胎数int num 4;//运行行为。public void run() {System.out.println(颜色:color 轮胎数: num);}
}
实例化
public class Main {public static void main(String[] args) {Car car new Car();car.run();}
}创建car对象时car引用的内存图 对象调用方法过程
首先我们看一段代码这是一个人类的class类代码
public class Person {private String name;private int age;private static String country cn;public Person(String name, int age) {this.name name;this.age age;}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 static void showCountry() {System.out.println(showCountry country);}public void speak() {System.out.println(this.getName() speak);}
}假如我们在main中编写这样一段代码请问在内存中他是如何工作的呢 public static void main(String[] args) {Person p new Person(张三, 18);p.setName(李四);}我们先从类类加载时开始分析由于static关键字修改的变量或者方法会随着jvm加载类时一起创建所以country和showCountry()在方法区是这样的。 然后main方法开始执行对应代码首先main方法入栈初始化一个p引用 堆区开辟一个空间创建一个person实例p引用指向这个内存空间 调用setNamesetName入栈完成name值修改之后销毁 成员变量和局部变量
作用范围
成员变量作用于整个类中。 局部变量变量作用于函数中或者语句中。
在内存中的位置
成员变量在堆内存中因为对象的存在才在内存中存在。 局部变量存在栈内存中。
关于对象的引用关系
简介
对象引用用于指向0个或者多个对象实例对象实例可以被多个对象引用指向。
相关代码
假如我们使用上文car类执行以下代码那么在内存中会如何执行呢
car cnew car();
c.num5;
car c1c;
c.run();内存图解
首先堆区开辟一个空间创建car对象初始化值修改num为5c1引用指向c如下图所示
对象相等和引用相等的区别
对象相等:两个对象内存中的存放的内容都相等引用相等:两个引用指向的内存地址相等。
类的构造方法的作用是什么
完成对象初始化首先在堆区创建对象实例。
构造方法的特点
与类名相同无返回值生成对象时自动执行不可重写可以重载
深拷贝和浅拷贝区别
浅拷贝
对象进行拷贝时如果内部有引用类型克隆对象仅仅是复制被克隆内部对象的引用地址
为了介绍浅拷贝我们贴出这样一段代码可以看到一个学生类有id和name以及一个Vector的引用对象
public class Student implements Cloneable {private String id;private String name;private VectorString vector;public String getId() {return id;}public void setId(String id) {this.id id;}public String getName() {return name;}public void setName(String name) {this.name name;}public VectorString getVector() {return vector;}public void setVector(VectorString vector) {this.vector vector;}public Student() {try {System.out.println(创建对象需要三秒......);Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}}public Student newInstance() {try {return (Student) this.clone();} catch (CloneNotSupportedException e) {e.printStackTrace();}return null;}}然后我们使用下面这段代码进行测试可以看到输出结果为true说明student2的vector是student1的。如下图所示克隆对象的内部引用对象和student1是通用的
Testpublic void cloneTest() throws CloneNotSupportedException {long start,end;startSystem.currentTimeMillis();Student studentnew Student();endSystem.currentTimeMillis();System.out.println(学生1创建时间长 (end-start));student.setId(1);student.setName(小明);VectorString v new Vector();v.add(000000);v.add(000001);student.setVector(v);startSystem.currentTimeMillis();Student student2 student.newInstance();endSystem.currentTimeMillis();System.out.println(学生2创建时间长 (end-start));for (String s : student2.getVector()) {System.out.println(s);}
// false则说明深拷贝成功System.out.println(student.getVector()student2.getVector());}深拷贝
了解了浅拷贝之后我们就可以解释深拷贝了克隆对象的内部引用对象都是全新复制出来的一份
基于上文student代码我们对此进行改造重写以下clone方法
Overrideprotected Object clone() throws CloneNotSupportedException {Student clone new Student();clone.setId(this.getId());clone.setName(this.getName());//避免clone导致浅拷贝问题VectorString srcVector this.getVector();VectorString dstVector new Vector();for (String v : srcVector) {dstVector.add(v);}clone.setVector(dstVector);return clone;}匿名对象
实例代码
如下所示在堆区创建一个对象实例用后即被销毁。为了介绍匿名对象我们首先需要编写一个汽车类
public class Car {//描述颜色private String color 红色;//描述轮胎数private int num 4;public String getColor() {return color;}public void setColor(String color) {this.color color;}public int getNum() {return num;}public void setNum(int num) {this.num num;}//运行行为。public void run() {this.setNum(num);System.out.println(颜色: color 轮胎数: num);}
}然后我们使用测试单元进行测试 Testpublic void anonymously(){new Car().run();}
上述代码的工作过程如下所示可以看到完成方法调用之后 匿名对象与实例对象的区别
实例代码
可以看到我们现实创建一个非匿名的汽车类和匿名汽车类并作为show方法的参数传入 public static void main(String[] args) {Car car new Car();show(car);show(new Car());/*** 输出结果* 颜色:black 轮胎数:4* 颜色:black 轮胎数:4*/}public static void show(Car c) {c.setNum(3);c.setColor(black);c.run();}图解匿名与非匿名内存运行
非匿名对象内存运行过程图解 匿名对象完成方法调用后即被销毁 使用场景 当对对象的方法只调用一次时可以用匿名对象来完成这样写比较简化。如果对一个对象进行多个成员调用必须给这个对象起个名字。 可以将匿名对象作为实际参数进行传递。
封装
什么是封装
以生活为例子某公司老板招开发人员招得开发人员后开发人员工作过程不用看到老板只关注开发结果而老板只看到开发结果这一现象即封装。
什么时private修饰
private :私有权限修饰符用于修饰类中的成员(成员变量成员函数)。私有只在本类中有效。
代码示例
如下所示setAge就是对age赋值的封装隐藏对年龄操作的细节用户只需通过这个方法完成自己需要的赋值动作即可
public class Person {private int age;public void setAge(int a) {if (a 0 a 130) {age a;speak();} elseSystem.out.println(feifa age);}public int getAge() {return age;}private void speak() {System.out.println(age age);}
}构造函数
什么是构造函数
对象一建立就会调用与之对应的构造函数。构造函数的作用可以用于给对象进行初始化。
构造函数的小细节
类默认有构造函数显示创建后默认构造类就消失。默认构造函数权限和类权限修饰符一致例如类权限为public则构造方法默认也为public除非显示修改权限。
构造代码块
构造代码块示例以及与构造方法的区别
构造代码块。
作用给对象进行初始化。
对象一建立就运行而且优先于构造函数执行。
和构造函数的区别
1. 构造代码块是给所有对象进行统一初始化在jvm完成类加载时就会运行方法也就是说调用静态方法的情况下构造代码块也会被执行
2. 而构造函数是给对应的对象初始化。构造代码块会随着对象实例的创建和运行。
public class Person {private String name;private int age;{System.out.println(person 类的构造代码块执行了);run();}public void run(){System.out.println(person run);}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;}}如下便是main函数的运行结果
public static void main(String[] args) {Person pnew Person();/*** person 类的构造代码块执行了* person run*/}this关键字
什么是this关键字
代表它所在函数所属对象的引用。简单来说调用对象方法的对象就是this关键字多代表的对象。
this的应用
解决构造函数初始化的问题
如下代码假如所有成员变量不加this编译器则不会找成员变量name导致赋值过程毫无意义。 输出结果 对此我们就可以使用this关键字即可解决问题
public class Person {private String name;private int age;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;}
}用于构造函数之间进行互相调用
注意:this语句只能定义在构造函数的第一行。
public Person(String name, int age) {this(name);this.age age;}public Person(String name) {this.name name;}static关键字
什么是static关键字
用法是一个修饰符用于修饰成员(成员变量成员函数). 当成员被静态修饰后就多了一个调用方式除了可以被对象调用外还可以直接被类名调用。类名.静态成员。
static特点
随着类的加载而加载。随着jvm完成类加载该变量或者方法就会被加载到方法区。静态会随着类的消失而消失。说明它的生命周期最长。优先于对象存在即静态变量先存在对象后存在。被所有对象所共享所以有时候我们需要考虑线程安全问题。可以直接被类名所调用。
实例变量和类变量的区别
实例变量随着对象的创建而存放在堆内存上而类变量即静态变量随着类加载而存放在方法区上。实例变量随着对象实例消亡而消亡而类变量随着类的消亡和消亡。
静态使用注意事项
静态方法只能访问静态变量实例对象则静态非静态都可以访问静态方法不可使用this和super关键字因为this和super都是对象实例的关键字this关键字是指向对象实例static关键字在类加载时候就能被指向故不可使用这两个关键字。
静态有利有弊
利处
随着类加载而创建每个对象公用一份无需每个实例到堆区创建一份。
弊处
生命周期长使用不当可能造成线程安全问题。访问有局限性静态方法只能访问静态相关变量或者方法。
错误代码示范 图解对象如何调用static变量
我们首先编写这样一段代码
public class Person {private String name;private int age;public static int staticVar4;}然后我们的main方法进行这样的调用在jvm内存是如何执行的呢 public static void main(String[] args) {Person personnew Person();person.staticVar5;}main方法入栈堆区创建person对象实例p指向实例p实例通过堆区对象操作方法的静态变量修改值为5 main函数
主函数
主函数是一个特殊的函数程序执行的入口可以被jvm执行。
主函数的定义格式以及关键字含义
public代表着该函数访问权限是最大的。 static代表主函数随着类的加载就已经存在了。 void主函数没有具体的返回值。 main不是关键字但是是一个特殊的单词可以被jvm识别。 String[] args:函数的参数参数类型是一个数组该数组中的元素是字符串。字符串类型的数组。
主函数是固定格式的
只有符合上述的固定格式,jvm才能识别。
jvm在调用主函数时传入的是new String[0];即可长度为0的String
如何使用args
class MainDemo
{public static void main(String[] args)//new String[]{String[] arr {hah,hhe,heihei,xixi,hiahia};MainTest.main(arr);}
}class MainTest
{public static void main(String[] args){for(int x0; xargs.length; x)System.out.println(args[x]);}
}静态代码块
格式
static
{静态代码块中的执行语句。
}我们在person类中编写一个静态代码块然后调用其他静态方法可以发现静态代码块会随着类的加载而完成执行并且只执行一次
public class Person {static {System.out.println(静态代码块随着方法执行而执行.....);}public static void func(){System.out.println(静态方法执行了);}}main方法调用示例 public static void main(String[] args) {Person.func();Person.func();/*** 输出结果* 静态代码块随着方法执行而执行.....* 静态方法执行了* 静态方法执行了*/}设计优化
单例模式
简介
对于重量级对象的创建可能会导致以下问题:
创建对象开销大GC压力大可能导致系统卡顿
饿汉式
代码如下所示可以看到对象随着类的加载就会立刻完成创建这就导致假如我们使用这个类的某些不需要单例的方法也会完成对象的创建。 例如我们就像调用以下Singleton 的sayHello这个静态方法就会导致单例实例被创建所以如果非必要我们不建议采用这种非延迟加载的单例模式
public class Singleton {private Singleton() {System.out.println(创建单例);}public static Singleton instance new Singleton();public static Singleton getInstance() {return instance;}public static void sayHello(){System.out.println(hello);}}测试代码可以看到调用静态方法单例就被被创建了
public static void main(String[] args) {Singleton.sayHello();/*** 输出:* 创建单例* hello*/}原理也很简单静态变量和方法都在方法区随着类被加载这些变量或者方法都会被加载。 懒汉式(线程不安全)
懒汉式即实现延迟加载的有效手段代码如下所示
/*** 延迟加载的单例类 避免jvm加载时创建对象*/
public class LazySingleton {private LazySingleton() {System.out.println(懒加载单例类);}private static LazySingleton instance null;public static LazySingleton getInstance() {if (instance null) {instance new LazySingleton();}return instance;}public static void sayHello(){System.out.println(hello);}}
调用示例如下所示可以看到静态方法调用后并没有创建实例只有调用获取对象时才会得到对象实例
public static void main(String[] args) {LazySingleton.sayHello();LazySingleton.getInstance();/*** 输出结果* hello* 懒加载单例类*/}懒汉式的工作原理如下图所示可以看到只有调用getInstance后才会在堆内存中开辟一块内存空间创建对象 实际上当前的懒汉式存在线程安全问题如上内存图解所示可能会有两个线程走到null的判断中进而出现创建多个单例对象的情况。我们使用JUC的倒计时门闩调用获取单例的情况可以看到对象被创建了多次。 /*** 不加synchronized的懒加载 加上则没有下面这样输出结果*/Testpublic void threadTest0(){ExecutorService threadPool Executors.newFixedThreadPool(1000);CountDownLatch countDownLatchnew CountDownLatch(1);for (int i 0; i 10000; i) {threadPool.submit(()-{System.out.println(LazySingleton.getInstance());try {countDownLatch.await();} catch (InterruptedException e) {e.printStackTrace();}});}countDownLatch.countDown();/*** 懒加载单例类* 懒加载单例类* 懒加载单例类* 懒加载单例类* com.optimize.design.LazySingleton12423874* com.optimize.design.LazySingleton350c55ec* com.optimize.design.LazySingleton350c55ec* com.optimize.design.LazySingleton350c55ec* 懒加载单例类* com.optimize.design.LazySingleton350c55ec* com.optimize.design.LazySingleton5897fc07* 懒加载单例类* com.optimize.design.LazySingleton5897fc07* 懒加载单例类* com.optimize.design.LazySingleton39d8305* com.optimize.design.LazySingleton1a0eae7f* com.optimize.design.LazySingleton1a0eae7f* 懒加载单例类* com.optimize.design.LazySingleton1a0eae7f* 懒加载单例类*/}懒汉式(线程安全)
要想实现线程安全我们只需要通过下面这种方式上锁即可保线程安全但是缺点也很明显在高并发情况下获取对象的实践会随着增加 /*** 增加 synchronized确保线程安全* return*/public synchronized static LazySingleton getInstance() {if (instance null) {instance new LazySingleton();}return instance;}测试用例如下可以看到饿汉式和线程安全懒汉式时间的差距
Testpublic void test(){long startSystem.currentTimeMillis();for (int i 0; i 100_0000; i) {Singleton.getInstance();}long endSystem.currentTimeMillis();System.out.println(end-start);startSystem.currentTimeMillis();for (int i 0; i 100_0000; i) {LazySingleton.getInstance();}endSystem.currentTimeMillis();System.out.println(end-start);/*** 输出结果** 创建单例* 3* 懒加载单例类* 20*/}内部类模式
上文提到的懒汉式的性能问题所以我们可以使用内部类模式解决该问题代码如下所示可以看到我们在单例类的内部增加一个静态内部类该类被加载时静态内部类并不会被加载只有调用getInstance才会创建单例对象并且该对象的创建是随着类的加载就完成创建故这是一种线程友好的单例模式
/*** 线程安全的单例 但还是会被反射攻破*/
public class StaticSingleton {private StaticSingleton() {System.out.println(静态内部类延迟加载);}private static class SingletonHolder {private static StaticSingleton instance new StaticSingleton();}public static StaticSingleton getInstance(){return SingletonHolder.instance;}public static void sayHello(){System.out.println(hello);}}测试代码和输出结果
public static void main(String[] args) {StaticSingleton.sayHello();StaticSingleton.getInstance();/*** 输出结果* * hello* 静态内部类延迟加载*/}内部类单例模式工作过程 实际上这种模式也有缺点就是会被发射攻破后续我们会介绍对应的解决方案
双重锁校验(线程安全)
双重锁校验的单例模式如下所示可以看到双重锁校验的编码方式和简单第一次判断避免没必要的执行第二次判断避免第一次判定为空走到创建对象代码块的线程从而避免线程安全问题
public class DoubleCheckLockSingleton {private static DoubleCheckLockSingleton instance null;private DoubleCheckLockSingleton() {System.out.println(双重锁单例对象被创建);}public static DoubleCheckLockSingleton getInstance() {if (instance ! null) {return instance;}synchronized (DoubleCheckLockSingleton.class) {//这一重校验是为了避免上面判空后进入休眠走到这个代码块的线程if (null instance) {instance new DoubleCheckLockSingleton();return instance;}}return instance;}}性能上我们可以看到双重锁校验的性能要好于静态内部类的方式 Testpublic void test(){long startSystem.currentTimeMillis();for (int i 0; i 100_0000; i) {Singleton.getInstance();}long endSystem.currentTimeMillis();System.out.println(end-start);startSystem.currentTimeMillis();for (int i 0; i 100_0000; i) {LazySingleton.getInstance();}endSystem.currentTimeMillis();System.out.println(end-start);startSystem.currentTimeMillis();for (int i 0; i 100_0000; i) {StaticSingleton.getInstance();}endSystem.currentTimeMillis();System.out.println(end-start);startSystem.currentTimeMillis();for (int i 0; i 100_0000; i) {DoubleCheckLockSingleton.getInstance();}endSystem.currentTimeMillis();System.out.println(end-start);/*** 创建单例* 6* 懒加载单例类* 20* 静态内部类延迟加载* 4* 双重锁单例对象被创建* 3*/}枚举单例模式(线程安全)
/*** 使用枚举保证类单例*/
public enum Elvis {INSTANCE;private String nameelvis;public String getName() {return name;}public static Elvis getInstance(){return INSTANCE;}public void leaveTheBuilding() {System.out.println(Whoa baby, Im outta here!);}}
可以看到这种方式不会被反射攻破
public static void main(String[] args) throws IllegalAccessException, InstantiationException {ClassElvis elvisClass Elvis.class;Elvis elvis1 elvisClass.newInstance();System.out.println(elvis1.getName()); }输出结果 相关面试题
下面这段代码。new StaticCode(4)的输出结果
public class StaticCode {int num 9;StaticCode() {System.out.println(b);}static {System.out.println(a);}{System.out.println(c this.num);}StaticCode(int x) {System.out.println(d);}public static void show() {System.out.println(show run);}
}
答案a c9 d
创建类加载顺序为:
加载静态代码块加载构造代码块加载构造方法
参考文献
Java基础常见面试题总结(中)
Effective Java中文版第3版
Java系统性能优化实战
