Day-6 面向对象（继承、抽象类、关键字）

 

第一节

/*
设计模式：一种解决问题行之有效的思想。

单例设计模式：保证一个类在内存中只能有一个对象。

比如多程序访问同一个配置文件，希望多程序操作的的都是同一配置文件中的数据。需要保证
该配置文件对象的唯一性。

如何实现对象的唯一？或者说怎么做，保证这个对象的唯一性？
思路：
1.其他程序随时用new对象创建该类的对象，无法控制个数。
结论：不让其他程序创建该类的对象，因为不可以控制。
2.该类在本类中自己创建一个对象，不让其他程序创建。
3.该类将创建的对象对外提供，让其他程序获取并使用。

步骤：
1.将该类中的构造函数私有化
2.在本类中创建一个本类对象。
3.定义一个方法，返回值类型是本类类型，让其他程序通过该方法就可以
获取到该类的对象。
*/

/*class Single//单例的加载方法---饿汉式
{
private static Single s = new Single();
private Single(){}
public Single getInstance();
{
return s;
}

class Single2//单例的延迟加载方法---懒汉式
{
private static Single2 s = null;
private Single2(){}
public static Single2 getInstance()
{
if(s==null)
s=new Single2();
return s;
}
}
}*/

 

class SuperMan//超人要保证唯一性,类里创建对象，用private修饰
{
private int age;
private String name;
private static SuperMan man = new SuperMan("超人");
private SuperMan(String name)
{
this.name = name;
}
public void setAge(int age)
{
this.age = age;
}
public int getAge()
{
return age;
}
public String getName()
{
return this.name;
}
public static SuperMan getInstance()
{
return man;
}
}

class SingleDemo
{
public static void main(String[] args)
{

SuperMan s1 = SuperMan.getInstance();
//System.out.println(s1.getName());
//System.out.println(s1.getAge());
SuperMan s2 = SuperMan.getInstance();
s1.setAge(20);
s2.setAge(18);
System.out.println(s1.getAge());
System.out.println(s2.getAge());
//结果：18 18
//原因：因为访问的是同一个对象，第一次值是20，第二次值变为18.

 

//Single s1 = Single.getInstance();//定义方法是为了控制语句。
//System.out.println(s1==s2);
}
}

 

第二节

class ArrayOperateDemo//获取数组最大值的数代码

{
public static void main(String[] args)
{
int[] arr = {2,5,6,9,0};

int max = getMax(int[] arr);
System.out.println("max=" +max);
}
public static int getMax(int[] arr)
{
int max = 0;

for (int x=1;x<arr.length ;x++ )
{
iff(arr[x]>arr[max])
max = x;
}
return arr[max];
}
}

第三节

class ArrayOpeateDemo{
public static void main(String[] args)
{
int[] arr = {1,4,5,6,65};
//创建具备数组操作工作类的对象
ArrayTool tool = new ArrayTool();
int max = tool.getMax(arr);

int max = getMax(arr);
System.out.println("max=" +max);

}
}

/**
这是一个用于操作数组的工具类
@autohor 张三
@vesion V2.1

*/
public class ArrayTool
{
/**
这是一个构造函数，用于给对象初始化

*/
ArrayTool(){}

/**
用于获取数组的最大值
@param arr 接收一个int类型的数组。
@return 返回数组中的最大值。


*/
public static int getMax(int[] arr)
{
int max = 0;

for (int x=1;x<arr.length ;x++ )
{
iff(arr[x]>arr[max])
max = x;
}
return arr[max];
}
/**
用于获取数组中的最小值
@param arr 接收一个int类型的数组。
@return 返回该数组中的最小值。


*/

public static int getMax(int[] arr)
{
int min = 0;

for (int x=1;x<arr.length ;x++ )
{
iff(arr[x]>arr[max])
max = x;
}
return arr[max];
}

}

第四节

/*

继承
1.好处：提高代码的复用性，让类与类之间产生关系
2.将对象的共性内容不断的向上抽取，就形成了关系，就有了继承，有了子父亲类，
提高了代码的复用性。

继承特点：
1.java中只能单继承，多继承的机制被java语言改良了。
单继承：一个类只有一个父类，
多继承：一个类可以有多个父类。
class A {}
class B{}
class c extends A;{}//单继承
class c entends A,B{}//多继承

java不支持多继承的原因：
1.会产生调用的不确定性

java支持多层继承，这样就出现了继承体系。

class B extends A{}
class C extends B{}
A
-B
—C

如何去使用一个继承体系中的成员呢？
1.查阅该体系中顶层的内容，因为通过该类可以了解该体系的基本功能
2.创建子类最多的的对象，既可以使用用共性的基本功能，也可以使用子类的特有功能。
加单说，看父类的内容，建子类对象使用。

什么时候使用继承呢？
必须是事务之间存在所属关系，才可以定义继承。
什么是所属关系？
***必须是XXX中的一种。
误区：不要仅仅为了提高复用，为了方便获取其他类中的内容而去继承。
class DemoA
{

void show1(){}
void show2(){}
}
class DemoB
{
void show1(){}
void show3(){}
}
B不能继承A，因为会继承A类里的show2()方法。

*/

class Person//父类
{
String name;
int age;
}

 

 

class Student extends Person//描述学生类,继承父类Person
{

//String name;
//int age;
void study()
{

}
}
class Worker extends Person//描述工作类,继承父类，Person
{
//String name;
//int age;
void study()
{

}
}

 

/*public static void main(String[] args)
{
System.out.println("Hello World!");
}
}*/

 

第五节

/*
继承中成员的特性
1.成员函数：
2.成员函数：
3.构造函数：

super:代表的是父类所属空间，用法和this相似
this:代表本类对象的引用

注意；
子父类中，通常不会出现同名的属性。父类中既然定义num属性，
就没必要在子类中在定义此属性，直接用就可以。
子类只能直接访问父类中非私有的变量。

 

*/

 

class Fu
{
private int num = 5;
public void setNum(int num)
{
this.num = num;
}
int num1 = 5;
}
class Zi extends Fu
{
int num2 = 7;
void show()
{
System.out.println(num1);
System.out.println(num2);
}
}
class ExtendsDemo2
{
public static void main(String[] args)
{
Zi z = new Zi();
z.show();
}
}

第六节

/*
继承中成员函数的特点：

当子父类出现一模一样的方法时，会发生一个函数的特性：覆盖（重写，
复写) override。
覆盖注意事项：
1.子类覆盖父类时，不许保证覆盖方法的权限大于等于被覆盖方法的权限。
public private
2.覆盖方法有静态修饰时，静态只能覆盖静态，或者静态覆盖。在写法注意事项。
*/
class Fu
{
void show()
{
System.out.println("Fu show run");
}
}
class Zi extends Fu
{
public void show()
{
System.out.println("Zi show run");

}
}

class ExtendsDemo3
{
public static void main(String[] args)
{
//Zi z = new Zi();
//z.show();
//Phone p = new Phone();
//p.show();

NewPhone n = NewPhone();
n.show();
}
}

/*覆盖的举例

描述一个手机，有一个来电显示的功能

*/
class Phone
{
void show();
{
System.out.println("number");
}
}
/*先新电话继承已有电话就可以获取其功能
继承了父类的功能，想要对已有的功能进行内容的改变
表示功能的声明不变，将内容在子类中进行定义，
这种定义就是覆盖。
*/
class NewPhone extends Phone
{
void show()
{
System.out.println("name");
super.show();//调用父类的show方法。
}
}

 

第七节

/*
继承中---构造函数
子类的实例化过程
其实就是子类的所有构造函数中的第一行，默认多有一条隐士的语句。
就是super();
问题：为什么子类的构造函数都要去访问父类的构造函数呢？
因为子类继承父类，可以访问父类的一些属性。
在子类进行实例化的时候必须要为父类中的属性分配空间。并要初始化吗
所有，必须要访问一次父列的构造函数，看看父类如何对其属性记性厨师石化。
所以子类实例化对象时，必须要先看父类的初始化过程。

结论：父类的构造函数，既可以对本类对象初始化，也可以给子类对象初始化。

如果父类中没有空参的构造函数，子类中的构造函数指定要访问父类中的函数。或者用
this来指定访问本类的构造函数。

this与super调用构造函数，不能放在函数的第一行，不能同时出现。为什么定义在第一行呢？
因为：初始化的动作要先执行。

Object类是java中的超类，就是第一类。
*/
class Fu
{
Fu()
{
System.out.println("Fu run");
}

}
class Zi extends Fu
{
//默认有super()
Zi()
{
System.out.println("Zi run");
}
}

class ExtendsDemo4
{
public static void main(String[] args)
{
new Zi();
}
}

 

第八节

class Person
{
private String name;
private int age;
Person(String name,int age)
{
this.name = name;
this.age = age;
}
public void setName(String name)

{
this.name = name;
}
public String getName()
{
return name;
}
public void setAge(int age)
{
this.age = age;
}
public int getAge()
{
return age;
}

}

class Student extends Person
{
Student(String name,int age)
{
super(name,age);
}
}
class Worker extends Person
{
Worker(String name,int age);
{
super(name,age);
}
}

class ExtendsDemo5
{
public static void main(String[] args)
{
Student A = new Student("xiaoming",19);
System.out.println(stu.getName());
System.out.println(stu.getAge());
}

}

 

第九节

/*
继承弊端：打破了封装性
final关键字的特点：
1.final关键字既可以修饰类，也可以修饰方法，还可以修饰变量
2.final修饰的类，不可以被继承
3.final修饰的方法不可以被覆盖
4.final修饰的变量是一个常量，只能赋值一次。
为了修饰固定的一些数据方便使用，会给这些起一个容易记住的名字
为了防止名称存储的数据改变，用final修饰
一般为final修饰的变量名称都是大写字符组成，如果存在多个单词，每个单词之间
用下划线分割。

记住：在开发的过程中，一旦程序中有固定的数据，一定要
将其用一个容易阅读的名称存储，并final修饰。

*/

class Fu
{
void show()
{
//调用了系统内的代码
}
}
class Zi extends Fu
{
static final int num = 9;//定义一个成员变量，static只能修饰成员变量， final可以修饰局部变量。

void show()
{
/*final int x = 4;//表示x终身为4，这个变量不会被改变。
final double PI = 3.14;
System.out.println(PI);
*/
}
}
class FinalDemo
{
public static void main(String[] args)
{
System.out.println();
}

}

 

第十节

class Fu
{
Fu()
{
show();
}

void show()
{
System.out.println("fu show run");
}


}

 

class Zi extends Fu
{
int num = 8;
{//构造代码块
System.out.println("cons code num="+num);
}
Zi()
{
System.out.println("cons function num="+num);
}
void show()
{
System.out.println("Zi show num="+num);
}
}

/*
一个对象在内存中的产生过程：
1.将该对象所需的类文件加载到内存中去。
2.在内存中进行空间方法去的划分
3.通过new 在堆内存中开辟空间
4，对象中的属性进行默认初始化
5.调用与之对象的构造函数进行初始化
6.通过构造函数的super调用父类中的构造函数初始化
7.对象中的属性进行显示初始化
8.构造代码块初始化
9.该构造函数内部定义内容进行初始化。

 

*/
class InitTest
{
public static void main(String[] args)
{
new Zi();
}
}

 

第十一节

/*
雇员示例：
需求：公司有程序员姓名，工号，薪水，工作内容
项目经理：除了有姓名，工号，薪水，还有奖金，工作内容等。
对给出需求进行建模。

对象1：程序员

属性：姓名、工号、薪水。
行为：工作内容
对象2：项目经理
属性：姓名，工号，薪水，奖金
行为：工作内容

程序员与经理之间不存在所属关系的，但是之间存在共性。
可以抽取到雇员（打工者）。

雇员类：
属性：姓名，工号，薪水
行为：工作内容。

 

*/
abstract class Employee
{
private String name;
private String id;
private String pay;
Employee(String name,String id,double pay)
{
this.name = name;
this.id = id;
this.pay = pay;
}
public abstract void work();
}
class Programmer extends Employee
{
Programmer(String name,String id,double pay)
{
super(name,id,pay);
}
public void work()
{
System.out.println("coding");
}
}
class Manager extends Employee

{
private double bonus;
Manager(String name,String id,double pay,double bonus)
{
super(name,id,pay);
this.bonus = bonus;
}
public void work()
{
System.out.println("manage");
}
}

《完》

 

转载于:https://www.cnblogs.com/cnbp/p/10269736.html