01-面向对象(数组工具对象建立)
ArrayTool.java里面的练习:
下面是一些数组工具的练习
练习的有:
l 获取整型数组的最大值。
// 获取整型数组的最大值。
public int getMax_1(int[] arr)
{
int max = arr[0];//初始化数组中的任何一个数
for (int i = 1; i < arr.length; i++) {
if (max<arr[i])
{
max = arr[i];
}
}
return max;
}
// 获取整型数组的最大值。
public int getMax_2(int[] arr)
{
int max = 0; // 初始化数组中的任何一个角标
for (int i = 0; i < arr.length; i++) {
if (arr[max]<arr[i])
{
max = i;
}
}
return arr[max];
}
l 对数组进行选择排序。
// 选择排序
public int[] 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])
{
swap(arr,i,j);
}
}
}
return arr;
}
l 获取指定的元素在指定数组中的索引.
public int arrIndex(int[] arr,int key)
{
for (int i = 0; i < arr.length; i++) {
if (arr[i]==key)
{
return i;
}
}
return -1;
}
l 将int数组转换成字符串。格式是：[e1,e2,...]
public String conString(int[] arr)
{
String str = "[";
for (int i = 0; i < arr.length; i++) {
if (i != arr.length-1)
{
str+=arr[i]+",";
}else
{
str+=+arr[i]+"]";
}
}
return str;
}
在这个工具类里面的设计原理也只要这个方法没有访问到这个对象里面的特有数据就应该静态化
private ArrayTool(){}//该类中的方法都是静态的，所以该类是不需要的创建对象的。为了保证不让其他成创建该类对象
//可以将构造函数私有化。
数组工具类-文档注释
Java中提供了一个工具来提取java文档中的注释，但前提是你在java文件是写了文档的注释才会被提取，这个工具就是javadoc
Javadoc的使用
单例设计模式-概述&体现
有了方法才可控
//饿汉式
class Single//类一加载，对象就已经存在了。
{
private static Single s = new Single();
private Single(){}
public static Single getInstance()
{
return s;
}
}
//懒汉式
class Single2//类加载进来，没有对象，只有调用了getInstance方法时，才会创建对象。
//延迟加载形式。
{
private static Single2 s = null;
private Single2(){}
public static Single2 getInstance()
{
if(s==null)
s = new Single2();
return s;
}
}
class SingleDemo
{
public static void main(String[] args)
{
Single s1 = Single.getInstance();
Single s2 = Single.getInstance();
System.out.println(s1==s2);
// Single ss =Single.s;
// Test t1 = new Test();
// Test t2 = new Test();
Test t1 = Test.getInstance();
Test t2 = Test.getInstance();
t1.setNum(10);
t2.setNum(20);
System.out.println(t1.getNum());
System.out.println(t2.getNum());
}
}
class Test
{
private int num;
private static Test t = new Test();
private Test(){}
public static TestgetInstance()
{
return t;
}
public void setNum(int num)
{
this.num = num;
}
public int getNum()
{
return num;
}
}
单例设计模式-内存图解
真真在面试的时候懒汉式一般问的比较多，然而也在真真的开发中饿汉式用的比较多为什么也不用懒汉式，因为在后面的多线程的时候会有问题，这里面只作一个了解
注意：子类不可以具备父类中私有的内容。
父类怎么来的？共性不断向上抽取而来的。
08-面向对象(继承-Java中的单继承和多重继承)
现在解释为什么java不直接支持多继承，事例:
class A
{
voidshow()
{
System.out.println("a");
}
}
class B
{
voidshow()
{
System.out.println("b");
}
}
class C extends A,B
{
}
newC().show();，当执行这条语句的时候也，C这个对象不知道调用哪一个，会产生不确定性，这就是为什么java不直接支持多继承的原因
因为多继承容易出现问题。
两个父类中有相同的方法。子类到底要执行哪一个是不确定的。
所以java不支持多继承，但将这种机制换了另一个种安全的方式来体现，多实现。
多次继承出现的继承体系中，通常看父类中的功能，了解该体系的基本功能，建立子类对象即可使用该体系功能。
面向对象(继承-子父类中成员变量的特点)
//1，成员变量。
class Fu
{
private int num = 4;
public int getNum()
{
return num;
}
}
class Zi extends Fu
{
private int num = 5;
void show()
{
System.out.println(this.num+"....."+super.getNum());
}
}
class ExtendsDemo2
{
public static void main(String[] args)
{
Zi z = new Zi();
z.show();
}
}
成员变量名字如果相同不存在一种覆盖,因为它们都有自己的所属
继承-子父类中成员变量的内存图解)
继承-子父类中成员函数特点-覆盖
//成员函数。
class Fu
{
public static void show()
{
System.out.println("fu show run");
}
}
class Zi extends Fu
{
public static void show()
{
System.out.println("Zi show run");
}
}
class ExtendsDemo3
{
public static void main(String[] args)
{
// Zi z = new Zi();
// z.show();
NewPhone p = new NewPhone();
p.show();
p.call();
}
}
继承-子父类中成员函数特点-覆盖的应用
class ExtendsDemo3
{
public static void main(String[] args)
{
// Zi z = new Zi();
// z.show();
NewPhone p = new NewPhone();
p.show();
p.call();
}
}
class honeP
{
void call()
{}
void show()
{
System.out.println("number");
}
}
class NewPhone extends Phone
{
void show()
{
System.out.println("name");
System.out.println("pic");
super.show();
}
}