JavaDay03总结
1、Error:(28, 1) java: 无法将类 Stu中的构造器 Stu应用到给定类型;
需要: int,java.lang.String,float
找到: 没有参数
原因: 实际参数列表和形式参数列表长度不同
修改：构造方法不会继承，当父类有带参构造方法时，子类要继承父类，父类需添加无参构造方法
2、继承：class 子类 extends 父类 子类拥有父类的属性和方法，父类的private修饰的属性不能被子类继承，若不希望子类继承父类的某个属性，则将该属性定义为private；之类最多直接继承一个父类，java所有类都是Object类的子类
3、重载：1.方法名相同 2.参数类型和个数至少一个不同 3.返回类型和修饰符可以不同
4、覆盖：子类有一个方法，与父类某方法的名称、返回类型、参数相同，则称子类方法覆盖父类方法；注：子类方法不能缩小父类方法的访问权限
5、多态：一个引用在不同情况下的多种状态，也可这样理解：通过指向父类的指针来调用不同子类中实现的方法；java允许父类的引用变量引用它的子类实例
这里写/*
作者：mys
功能：演示多态性
日期：2018/7/13
*/
package cn.mys;
public class Demo11
{
public static void main(String []args)
{
/*Animal animal=new Animal();
animal.show();
Cat cat=new Cat();
cat.show();
Dog dog=new Dog();
dog.show();
*/
/* 父类的引用变量引用它的子类
Animal an=new Cat();
an.show();
an=new Dog();
an.show();*/
Master master=new Master();
master.feed(new Cat(),new Fish());
master.feed(new Dog(),new Bone());
}
}
//食物
class Food
{
public void showName()
{
System.out.println("不知道什么名字");
}
}
//鱼类
class Fish extends Food
{
public void showName() {
System.out.println("鱼类");
}
}
//骨头类
class Bone extends Food
{
public void showName()
{
System.out.println("骨头类");
}
}
//人类
class Master
{
//给动物喂食
public void feed(Animal an,Food f)
{
an.eat();
f.showName();
}
}
//父类Animal
class Animal
{
public void show()
{
System.out.println("我是动物类！");
}
//动物吃
public void eat()
{
System.out.println("我不知道吃什么！");
}
}
//子类Cat
class Cat extends Animal
{
//覆盖父类
public void show()
{
System.out.println("我是猫类！");
}
//猫吃鱼
public void eat()
{
System.out.println("猫吃鱼！");
}
}
//子类Dog
class Dog extends Animal
{
//覆盖父类
public void show()
{
System.out.println("我是狗类！");
}
//狗吃骨头
public void eat()
{
System.out.println("狗吃骨头！");
}
}
6、约瑟夫问题
/*
作者：mys
功能：约瑟夫
日期：2018/7/13
*/
/*
问题：设编号1 2 3 4....n的n个人围成一圈，约定编号为k的人开始从1报数，
数到m的那个人出列，他的下一位又从1开始报数，直到所有人出列。
*/
package cn.mys;
public class Josephu
{
public static void main(String []args)
{
//创建一个环形链表
CycLink cyclink=new CycLink();
cyclink.setLen(5);//链表长度
cyclink.createLink();//初始化链表
cyclink.show();//显示链表
cyclink.setK(2);//设置开始数数人的编号
cyclink.setM(2);//设置数到几的人退出
cyclink.play();//开始数数
}
}
//定义一个小孩类
class Child
{
int num;//编号
Child nextChild=null;//指向下一个小孩
public Child(int num)//初始化编号
{
this.num=num;
}
}
//定义环形链表
class CycLink
{
//定义一个指向第一个小孩的引用
Child firstChild=null;
Child temp=null;
int len=0;
int k=0;
int m=0;
//设置m
public void setM(int m)
{
this.m=m;
}
//设置k
public void setK(int k)
{
this.k=k;
}
//设置链表大小
public void setLen(int len)
{
this.len=len;
}
//初始化循环链表
public void createLink()
{
for(int i=1;i<=len;i++)
{
if(i==1)
{
//创建第一个小孩
Child ch = new Child(i);
this.firstChild=ch;
this.temp=ch;
}
else if(i==len)
{
//创建最后一个小孩
Child ch=new Child(i);
temp.nextChild=ch;//搭桥
temp=ch;//temp向下走一步
temp.nextChild=firstChild;//环形链表最后一个小孩指向第一个小孩
}
else
{
//继续创建小孩
Child ch = new Child(i);
temp.nextChild=ch;//搭桥
temp=ch;//temp向下走一步
}
}
}
//显示链表
public void show()
{
Child temp=firstChild;//从第一个小孩开始
do {
System.out.println(temp.num);
temp=temp.nextChild;
}while(temp!=firstChild);
}
//开始play
public void play()
{
while(len!=1)
{
//1.找到开始数数的人
Child temp = firstChild;
for (int i = 1; i < k; i++)//注意此处i!=k
{
temp = temp.nextChild;
}
//2.数m下
for (int j = 1; j < m; j++) {
temp = temp.nextChild;
}
//找到要出圈小孩的前一个小孩
Child temp2 = temp;//temp2从temp开始
while (temp2.nextChild != temp)//找到temp2，其下一个小孩等于temp小孩
{
temp2 = temp2.nextChild;
}
//3.将数到m的小孩退出圈
temp2.nextChild = temp.nextChild;
temp = temp.nextChild;//temp指向下一个数数的小孩
this.len--;
}
//打印最后一个小孩
System.out.println("最后一个小孩："+temp.num);
}
}
7、抽象类：当父类的方法不能确定时，用abstract关键字修饰该方法（抽象方法），该类（抽象类）；当一个继承类的父类是抽象类的话，需要把抽象类中的所有方法全部实现
注意事项：
- 抽象类不能被实例化
- 抽象类不一定有抽象方法
- 一旦类包含了abstract方法，则该类必须声明为abstract
- 抽象方法不能有主体
eg.abstract void aaa(){}错误
/*
作者：mys
功能：抽象类的必要性
日期：2018/7/13
*/
package cn.mys;
public class Demo12 {
public static void main(String []args)
{
Cat cat=new Cat();
//Animal an=new Animal(); 抽象类不能被实例化
}
}
//父类Animal(抽象类)
abstract class Animal
{
//叫
//abstract public void cry(); 抽象类不一定有抽象方法
// abstract public void cry(){} 抽象方法不能有主体
public void aaa()//抽象类中可以有实现了的方法：普通方法
{
System.out.println("aaa");
}
}
//子类Cat
// 当一个继承类的父类是抽象类的话，需要把抽象类中的所有方法**全部实现**
class Cat extends Animal
{
//实现父类
public void cry()
{
//do nothing...
}
}
8、接口：给出一些没有内容的方法，封装到一起，某各类要使用的时候，根据具体情况写出方法，语法：class 类名 implements 接口{ 方法； 变量；}
注意事项：
- 1.接口不能实例化
2.接口中所有的方法都不能有主体
3.一个类可以实现多个接口
4.接口中可以有变量（但不能被private、protected修饰）
【a】接口中的变量都是 static,且是final类型，因此在定义时需要初始化
【b】java开发中，将常用的变量定义在接口中，作为全局变量使用。访问方式：接口名.变量名
5.一个接口不能继承其他的类，但可以继承别的接口
小结：接口是更加抽象的抽象类，抽象类中的方法可以有主体，而接口中的方法都没有主体，接口体现了多态和高内聚低耦合的设计思想。
/*
作者：mys
功能：接口（计算机 USB 相机 手机）
日期：2018/7/13
*/
package cn.mys;
public class Demo13 {
public static void main(String []args)
{
//在接口中定义的变量通过*接口名.变量名*调用
System.out.println(Usb.a);
//创建一个计算机
Computer computer=new Computer();
//创建一个相机
Camera camera=new Camera();
//创建一个手机
Phone phone=new Phone();
//使用接口
computer.useUsb(camera);
computer.useUsb(phone);
//Usb Usb=new Usb();接口不能实例化
}
}
//usb接口
interface Usb
{
//接口可以定义变量，且变量是static,因此在定义时也要初始化
int a=1;
//声明两个方法
//开始工作
public void start();
//停止工作
public void stop();
//public void stop(){} 接口中所有方法不能有主体
}
//一个类
class Bbb
{
}
//一个接口,不能继承其他的类
/*interface Aaa extends Bbb
{
}*/
//一个接口
interface Aaa
{
}
//编写相机类，并实现Usb接口
//一个重要原则：当一个类实现了一个接口，就要把该接口的方法都实现
class Camera implements Usb,Aaa//一个类可以实现多个接口
{
//实现两个方法
public void start()
{
System.out.println("相机开始工作");
}
public void stop()
{
System.out.println("相机停止工作");
}
}
//编写手机类
class Phone implements Usb
{
//实现两个方法
public void start()
{
System.out.println("手机开始工作");
}
public void stop()
{
System.out.println("手机停止工作");
}
}
//编写计算机类
class Computer
{
//使用Usb接口
public void useUsb(Usb usb)
{
usb.start();
usb.stop();
}
}