版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/zhaostrong/article/details/79708306
面向对象,数组工具的建立和对象继承
优化：
package com.ttzx.study.utils;
/**
* 建立一个用于操作数组的工具类，其中包含着常见的对数组操作的函数，如：最值排序等。
* @author 子龙
* @version V1.0
*
*/
public class ArrayTool {
private ArrayTool() {}//该类中的方法都是静态的，所以该类是不需要创建对象的，为了保证不让其他的创建该类对象可以将构函数私有化
/**
* 获取整型数组的最大值
* @param arr 传入整型数组。
* @return 返回该数组中的最大元素值。
*/
public static int getMax(int[] arr) {
int maxIndex = 0;
for (int x = 1; x < arr.length; x++) {
if (arr[x] > arr[maxIndex]) {
maxIndex = x;
}
}
return arr[maxIndex];
}
/**
* 对数组选择排序
* @param arr 接收一个int类型的数组
*/
public static void selectSort(int[] arr) {
for (int x = 0; x < arr.length - 1; x++) {
for (int y = x + 1; y < arr.length; y++) {
if (arr[x] > arr[y]) {
swap(arr, x, y);
}
}
}
}
/*
* 用于给数组进行元素的位置置换
* @param arr int类型的数组
* @param x 需要置换元素的角标
* @param y 需要置换元素的角标
*/
private static void swap(int[] arr, int x, int y) {
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
/**
* 获取指定的元素在指定数组中的索引
* @param arr 要查询的int数组
* @param key 要找的元素
* @return 返回元素第一次出现的位置，如果不存在返回-1
*/
public static int getIndex(int[] arr, int key) {
for (int x = 0; x < arr.length; x++) {
if (arr[x] == key) {
return x;
}
}
return -1;
}
/**
* 整型数组转字符串 格式是[ e,e2,e3.....]
* @param arr 接收整型的int数组
* @return 返回一个固定格式的字符串
*/
public static String arrayToString (int []arr) {
String str="";
for(int i=0;i<arr.length;i++) {
if(i!=arr.length-1) {
str=str+arr[i]+",";
}else {
str=str+arr[i]+"]";
}
}
return str;
}
}
注意当使用javadoc 导出文档注释时，需要添加-encoding UTF-8 -charset UTF-8如下：
将-encoding UTF-8 -charset UTF-8这一段复制到elipse的相应输入框中，如下图：
面向对象 设计模式——单例设计模式 概述、体现
输出的结果是 true
单例设计模式 ——懒汉式
饿汉式（实际都用饿汉式较多。）
面相对象之继承
概述
java中支持单继承，不直接支持多继承，但对C++中的多继承机制进行改良
成员变量的体现：
成员方法的体现：
输出的结果是：
什么时候用覆盖操作
面向对象——继承，子父类构造函数，子类的实例化过程
package com;
/**
* 在子类构造对象时，发现访问子类构造函数，父类也运行了。
* 为什么呢?
* 原因是：在子类的构造函数中第一行有一个默认的隐式语句。super()
* @author Administrator
*
*/
public class ExtendsDemo3 {
public static void main(String[] args) {
// TODO Auto-generated method stub
new ExtendsDemo3().new Zi();
}
class Fu{
public Fu() {
// TODO Auto-generated constructor stub
System.out.println("Fu...");
}
}
class Zi extends Fu{
public Zi() {
//super();//调用的就是弗雷中的空参数的构造函数
// TODO Auto-generated constructor stub
System.out.println("Zi...");
}
}
}
package com;
public class ExtendsDemo33 {
public static void main(String[] args) {
// TODO Auto-generated method stub
new ExtendsDemo33().new Zi();
}
//为什么子类实例化的时候要访问父类中的构造函数？
//那是因为子类继承父类，获取到了父类中内容，所以在使用父类内容之前，要先看父类是如何对自己的内容进行初始化的。
//所以子类在构造对象时，必须访问父类中的构造函数。
//为什么完成这个必须的动作，就在子类的构造函数中加入super()语句
//如果父类中没有定义空参数构造函数，那么子类的构造函数必须用super明确要调用父类中的那个构造函数。同时子类构造函数中如果使用this调用了本类构造函数时，那么super就没有了，因为super和this都只能定义第一行，所以只能有一个。
但是可以保证的，子类中肯定会有其他的构造函数来访问父类的构造函数
//注意super语句必须要定义在子类构造函数的第一行，因为父类的初始化先完成。
class Fu{
public Fu() {
// TODO Auto-generated constructor stub
System.out.println("Fu...A");
}
public Fu(int x) {
//super();//调用的就是父类中的空参数的构造函数
// TODO Auto-generated constructor stub
System.out.println("Fu...B"+x);
}
}
class Zi extends Fu{
public Zi() {
//super();//调用的就是父类中的空参数的构造函数
// TODO Auto-generated constructor stub
System.out.println("Zi...C");
}
public Zi(int x) {
System.out.println("Zi...D"+x);
}
}
}面向对象——继承，子父类构造函数，子类的实例化过程（细节）
package com;
public class T {
public static void main(String[] args) {
Zi z = new T().new Zi();
z.show();
}
class Fu {
public Fu() {
super();
show();
return;
}
void show() {
System.out.println("fu.....show");
}
}
class Zi extends Fu {
int num = 8;
public Zi() {
super();
//通过super初始化父类内容时，子类的成员变量并未显示初始化。等super()父类初始化完毕后，才进行初始化。
System.out.println("zi cons run...."+num);
return;
}
void show() {
System.out.println("zi show " + num);
}
}
/**
* 一个对象实例化过程：
* Person p=new Person();
*
* 1.JVM 会读取指定的路径下的Person.class 文件，并加载进内存，
* 并会先加载Person的父类（如果有直接的父类的情况下）。
* 2.在堆内存中开辟空间，分配地址。
* 3.并在对象空间中，对对象中的属性进行默认初始化。
* 4.调用对应构造函数进行初始化
* 5.在构造函数中，第一行会先调用父类中的构造函数，进行初始化。
* 6.默认初始化完毕后，在对子类的属性显示初始化。
* 7.在进行子类构造函数的特定初始化
* 8.初始化完毕后，降低至值赋值给引用变量。
*
*/
//输出的结果是：
zi show 0
zi cons run....8
zi show 8
}
final 关键字
package com.myfinal;
public class StudyFinal {
/*
* 继承弊端： 打破了封装性
*
*/
/**
* final 关键字
* 1.final 是一个修饰符，可以修饰类，方法，变量。
* 2.final 修饰的类不可以被继承。
* 3.final修饰的方法不可以被覆盖。
* 4.final修饰的变量是一个常量，只能赋值一次。
*
* 为什么要用fianl 修饰变量，其实在程序如果一个数据是固定的。
* 那么直接使用这个数据就可以了，但是这样阅读性差，所以它该数据七个名称。
* 而且这个变量名称值不能变化，所有加上final固定。
*
* 写法规范，常用所有字母大写，如果多个单词连接用_连接。
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
}
}
面向对象 抽象类
package myAbstract;
public class AbstractDemo {
/*
* 抽象类： 抽象：笼统、模糊，看不懂！不具体。
*/
public static void main(String[] args) {
}
/**
* DemoA和DemoB 具体功能不一样
*
* @author Administrator
*
*/
class DemoA extends Demo {
@Override
void show() {
System.out.println("demoa show");
}
}
class DemoB extends Demo {
void show() {
System.out.println("demob show");
}
}
}
package myAbstract;
public abstract class Demo {
abstract void show();
}
面向对象抽象类的特点：
* 特点：
* 1.方法只有声明没有实现时，该方法就是抽象方法，需要被abstract修饰。
* 抽象方法必须定义在抽象类中，该类必须也是abstract。
* 2.抽象类不可以被实例化，为什么？因为调用抽象方法没有意义。
* 3.抽象类必须有其子类覆盖了所有的抽象方法后，该子类才可以实例化。否则这个子类还是抽象类。
面向对象抽象类细节：
/**
* 1.抽象类中有构造函数吗？
*
* 有 ，用于给子类对象进行初始化。
*
* 2.抽象类可以不定义抽象方法吗？
* 可以，目的是不让这个类创建对象。AWT的适配器对象就是这种类。
* 通常这个类中的方法有方法体，但是却没有内容。
*
*
* 3.抽象类关键字不可以和那些关键字共存？
*
* private 不行，如修饰了抽象方法，不能被子类覆盖了。
* static 不行，如果能用static 就不需要在创建对象了，那就直接用类名.方法名。但是方法没有方法体没有任何意义。
* final 不行，final 修饰的不能被继承，所以这个抽象类也就不能继承了，也就没有啥意义
*
*
* 4.抽象类和一般类的异同点？
* 相同点：
* 抽象类和一般来都是用类描述事物的，都在内部定义了成员。
* 不同：
* 1.一般类有足够的信息描述事物。
* 抽象类描述事物的信息可能不足。
* 2.一般类中不能定义抽象方法，只能定义非抽象方法
* 抽象类中可以定义抽象方法，也可以定义非抽象方法。
* 3.一般类可以被实例化，抽象类不可以实例化。
*/