一、笔记内容概述:
面向对象(数组工具对象建立-文档注释-单例设计模式&内存图解)、继承、单继承和多重继承。
二、常用内容介绍:
1.继承的好处:提高了代码的复用性;让类与类之间产生了关系;开发最终的核心内容：不断地创建对象，使用对象，并维护着对象之间的关系。
2.什么时候使用继承?
当类与类之间存在着所属关系的时候，就定义继承;java不直接支持多继承，因为多个父类中如果有相同成员时，就会出现调用的不确定性;java中通过多实现implements的方式来间接体现多继承;
3.如何学习一个继承体系？
查看该体系中的最顶层类，了解该体系的基本功能;创建体系中的最子类对象，完成功能的使用。
4.成员变量的特点:
对于变量的值，子类有就不找父类，局部要是有值，就不会找成员变量的值;
细节a：当本类中的成员和局部成员同名时，用this区分，当子父类中的成员变量同名时，用super，区分父类 ;细节b:子类不能直接访问父类中的私有的内容，但是可以调用父类对外提供的公共方法调用父类中的私有内容。
5.重载和重写的区别：
重载发生在同一个类中，重写发生在子父类中;子类方法覆盖父类方法时，子类权限必须要大于等于父类的权限;静态方法只能覆盖父类的静态方法，或者被其下一个子类的静态方法覆盖。
三、经典示例及讲解:
1.使用工具类求数组的最大值。
工具类Tools.java
package com.date8;
/**
*从节省内存空间角度
*可以将工具类中的方法定义成静态的，
*这样就直接可以通过类名调用，不需要创建对象。
*
*建立一个用于操作数组的工具类，其中包含着常见的对数组操作的函数如：最值，排序等
*@author zengwei
*@version 1.0.1
*/
public class Tools {
/*不允许本类创建对象*/
private Tools(){
}
/**
*获取整型数组的最大值
*/
public static int getMax(int[] arr){
int index = 0;
for(int i=1;i<arr.length;i++){
if(arr[i]>arr[index]) index = i;
}
return arr[index];
}
/**
* 冒泡排序
* @param arr
*/
public static void maoPaoSort(int[] arr){
for(int i=arr.length-1;i>1;i--){
for(int j=1;j<i;j++){
if(arr[j]>arr[j+1]){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
/**
*选择排序
*/
public static void selectSort(int[] arr){
for(int i=0;i<arr.length-1;i++){
for(int j=i+1;j<arr.length;j++){
if(arr[i]>arr[j]){
int temp = 0;
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}
/**
* 插入排序
* @param arr
*/
public static void insertion(int[] arr){
for(int i=1;i<arr.length;i++){
//insertIndex无序元素要插入的位置
int insertIndex = i;
int current = arr[i];
for(int j=i-1;j>=0;j--){
if(current<arr[j]){
//比较数后移
arr[j+1] = arr[j];
//插入位置前移
--insertIndex;
}else{
break;
}
}
//直接将数据插入
arr[insertIndex] = current;
}
}
/**
*快速查找法
*/
public static int getIndex(int[] arr,int key){
for(int i=0;i<arr.length;i++){
if(arr[i]==key) return i;
}
return -1;
}
}
测试代码
package com.date8;
//使用工具类方式求数组的最大值(使用面向对象的思想)
public class Test1 {
public static void main(String[] args){
int[] arr = {1,4,7,2,5,8,3,6,9};
int max = Tools.getMax(arr);
Tools.insertion(arr);
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
System.out.println("max="+max);
System.out.println(Tools.getIndex(arr, 9));
}
}
2.单例设计模式介绍
package com.date8;
/**
*单例设计模式
*/
class Single{
private static Single s = new Single();//s属于引用成员变量 private 私有化，用于可控
private Single(){}//私有化构造函数
public static Single getInstance(){
return s;
}
}
public class Test2 {
public static void main(String[] args){
// Single s1 = Single.getInstance();
// Single s2 = Single.getInstance();
// System.out.println(s1==s2);
Exam t1 = Exam.getInstance();
Exam t2 = Exam.getInstance();
t1.setNum(10);
t2.setNum(20);
System.out.println(t1.getNum());
System.out.println(t2.getNum());
}
}
class Exam{
private int num;
private static Exam e = new Exam();//私有化对象
private Exam(){}//私有化构造函数
public static Exam getInstance(){//获取实例对象
return e;
}
public void setNum(int num){
this.num = num;
}
public int getNum(){
return num;
}
}
3.单例设计模式的两种情况(饿汉式和懒汉式)
package com.date8;
public class Test3 {
public static void main(String[] args) {
}
}
/**
*饿汉式
*/
class easy{
private static easy s = new easy();
/**
*私有化构造函数，防止其他类创建本类对象
*/
private easy(){}
/**
*获取实例对象
*/
public static easy getInstance(){
return s;
}
}
/**
*懒汉式 (存在线程安全隐患)需要加线程锁
*/
class lazy{
private static lazy l = null;
private lazy(){}
public static synchronized lazy getInstance(){
if(l==null){
l = new lazy();
}
return l;
}
}
4.继承的示例(结合上面理论)
package com.date8;
/**
*继承的好处：
*/
class Person{//父类
String name;
int age;
}
class Student extends Person{
void study(){
System.out.println(name+"...student study..."+age);
}
}
class Worker extends Person{
void work(){
System.out.println(name+"...Worker work..."+age);
}
}
public class Test4 {
public static void main(String[] args) {
Student p = new Student();
p.name = "张三";
p.age = 18;
p.study();
Worker w = new Worker();
w.name = "王五";
w.age = 30;
w.work();
}
}
5.子父类中，成员变量的特点:(结合上面理论)
package com.date8;
/***
* 在子父类中，成员的特点体现：
*/
class Fu{
private int money = 100;//子类不能直接访问
int num = 4;
public int getMoney(){
return money;
}
}
class Zi extends Fu{
int num = 5;
void show(){
System.out.println(num+"....."+super.num+"......"+super.getMoney());
}
}
public class Test5 {
public static void main(String[] args) {
Zi z = new Zi();
z.show();
}
}
6.子父类中成员函数的特点：
package com.date8;
/**
*二、子父类中成员函数特点
* 1.当子父类中有同名成员函数时，子类会覆盖父类
* 2.下面的eat方法不能成为覆盖，因为子类无法直接访问父类的私有成员和方法，
* 所以不存在覆写这一说法
* 3.当对一个类进行子类的扩展时(软件升级)，子类需要保留父类的功能
* 但是又要定义子类中该功能的特有内容时，就使用覆盖操作完成。
*
*/
class father{
public String s = "看书";
public void show(){
System.out.println("fu..."+s);
}
void eat(){
System.out.println("fu......吃西瓜");
}
}
class son extends father{
public String s = "玩游戏";
public void show(){//直接覆盖父类的方法
System.out.println("son..."+s);
}
public void eat(){
System.out.println("son......喝可乐");
}
}
public class Test6{
public static void main(String[] args) {
new son().show();
new son().eat();
}
}
版权声明：本文为博主原创文章，未经博主允许不得转载。
时间： 2024-12-22 11:33:23