1.方案-建立数组工具类,并在另一个类中调用
class ArrayToolDemo
{
/*
保证程序的独立运行。
*/
public static void main(String[] args)
{
int[] arr = {4,8,2,9,72,6};
//调用ArrayTool工具类方法,获取最值
int max = ArrayTool.getMax(arr);
System.out.println("max="+max);
//调用方法,将数组转成字符串
String str = ArrayTool.arrayToString(arr);
System.out.println(str);
//调用选择排序方法
ArrayTool.selectSort(arr);
System.out.println(ArrayTool.arrayToString(arr));
}
2.单例设计模式
代码如下:
//饿汉式
public class SingleDemo {
//在本类中创建实例对象
private static SingleDemo singleDemo = new SingleDemo();
//私有化构造函数
private SingleDemo(){}
//提供方法供外界访问对象
public static SingleDemo getInstance() {
return singleDemo;
}
}
//懒汉式
public class SingleDemo1 {
//先不创建对象
private static SingleDemo1 singleDemo = null;
//私有化构造函数
private SingleDemo1(){}
//提供方法供外界访问对象,调用方法时才创建对象
public static SingleDemo1 getInstance() {
if(singleDemo == null)
singleDemo = new SingleDemo1();
return singleDemo;
}
}
3.继承(extends)
不用自己写父类中已有的代码。
继承时使用extends关键字来实现子类继承父类。
简单的代码示例:
class Person
{
String name;
int age;
}
class Student extends/*继承*/ Person
{
// String name;//子类继承父类的内容,可以直接使用父类中的name和age
// int age;
void study()
{
System.out.println(name+"...student study.."+age);
}
}
class Worker extends Person
{
// String name;
// int age;
void work()
{
System.out.println(name+"worker work"+age);
}
}
class ExtendsDemo
{
public static void main(String[] args)
{
Student s = new Student();
s.name= "zhangsan";
s.age = 22;
s.study();
}
}
来体现。
class Fu
{
Fu(){
System.out.println("fu run");
}
}
class Zi extends Fu
{
Zi(){
//super();//隐含调用了父类的空参数的构造函数
System.out.println("zi run");
}
}
4.多态
多态在代码中的体现:父类或者接口指向其子类的对象。
(1)多态的好处和弊端:
(2)多态—转型
可以结合代码说明:
abstract class Animal
{
code...
}
class Dog extends Animal
{
code...
}
class Cat extends Animal
{
code...
}
class AnimalDemo
{
public static void main(String[] args)
{
Animal a = new Cat();//向上转型
Cat c = (Cat)a;//向下转型
Animal a1 = new Dog();
Cat c1 = (Cat)a1;//ClassCastException//转化异常,猫和狗不存在继承关系。
}
}
转型分为:
(3)多态成员的特点:
5.接口
例化。否则,这个子类就是一个抽象类。
6.final关键字
写法规范:常量所有字母都大写,多个单词,中间用“_”连接。
7.内部类
内部类,其实相当于一种封装。一般用于类的设计。
class Outer
{
int num = 3;
class Inner
{
int num = 4;
void show()
{
int num = 5;
System.out.println(num);//打印5
System.out.println(this.num);//打印4
System.out.println(Outer.this.num);//打印3
}
}
void method()
{
new Inner().show();
}
}
(3)内部类-局部内部类
且看看一下代码说明:
class Outer
{
int num = 3;
void method()
{
final int x = 9;
class Inner
{
void show()
{
System.out.println("show..."+num);
System.out.println("show..."+x);
//从内部类中访问本地变量x,x需要被声明为final
//x为局部变量,生命周期较短,出栈后,对象无法访问。
}
}
Inner in = new Inner();
in.show();
}
}
class InnerClassDemo3
{
public static void main(String[] args)
{
new Outer().method();
}
}
(4)内部类-匿名内部类
public void method(){
// new Inner().show();
new Demo(){ //匿名内部类
void show(){
System.out.println("show"+num);
}
}.show();
}
}