java基础1

来源：互联网发布：sqlserver导入数据库编辑：程序博客网时间：2024/05/17 22:52

文件结构

Java访问修饰符

com.xiaoming / XiaoMing.java:

package com.xiaoming;
import java.util.*;
import com.xiaoqiang.*;
public class XiaoMing {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
HashMap hm=new HashMap();
Cat cat1=new Cat();
System.out.println(cat1.getName());
}
}
class Dog
{
}

com.xiaoqiang / Cat.java:

package com.xiaoqiang;
public class Cat {
public int a;
protected String name;
String color;
private float price;
//提供一个访问name的成员方法
public String getName()
{
return this.name;
}
}

com.xiaoqiang / Test2.java:

package com.xiaoqiang;
public class Test2 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Dog dog1=new Dog();
System.out.println(dog1.a);
}
}
class Dog
{
public int a;
protected String name;
String color;
private float price;
public void abc1()
{
System.out.println(a);
}
}

Com.XiaoQiang /XiaoQiang.java:

package com.xiaoqiang;
public class XiaoQiang {
/**
* @param args
*/
public static void main(String[] args) {
}
}

com.test / Test.java:

/*
* 功能：抽象类的必要性
*/
package com.test;
public class Test {
/**
* @param args
*/
public static void main(String[] args) {
//Animal an=new Animal();//抽象类不能被实例化
}
}
abstract class Animal //抽象类
{
String name;
int age;
//动物会叫
/*
public void cry()//父类方法不确定性
{
System.out.println("不知道怎么叫！");
}
*/
public void aaa()
{
System.out.println("抽象类中的实现方法");
}
//抽象类中可以包含实现了的方法
abstract public void cry();//抽象方法
//抽象类的特征：
//1.抽象类不能被实例化
//2.抽象类可以没有抽象方法
//3.包含了abstract(抽象)方法的类，必须声明为abstract
//4.抽象方法不能有主体，即不能有{}
}
class Cat extends Animal
{
//当一个类继承的父类是抽象类的话，就需要在子类在把抽象类
//的所有抽象方法全部实现
//实现
public void cry()
{
System.out.println("猫猫叫。。。");
}
}

com.test2 / Test.java:

/*
* 功能：接口的案例
*/
package com.test2;
public class Test {
/**
* @param args
*/
public static void main(String[] args) {
System.out.println(Usb.a);
//创建一个计算机
Computer computer=new Computer();
//创建Camera
Camera cameral=new Camera();
//创建手机
Phone phone1=new Phone();
computer.useUsb(cameral);
computer.useUsb(phone1);
}
}
//Usb接口
interface Usb
{
int a=1;
public void start();
public void stop();
}
interface aaa
{
public void Eee();
}
interface kkk extends aaa
{
public void cry();
}
//接口不能被实例化，且接口中不能含有实现了的方法
//接口可以理解成更加抽象的抽象方法
//接口中可以有被初始化的public,static,final类型的变量
//接口不能继承类，接口可以继承接口
//一个重要的原则：当一个类实现了一个接口，
//就要求该类把这个接口的所有方法都实现
class Camera implements Usb,kkk //一个类实现多个方法
{
public void start()
{
System.out.println("相机，开始工作了！");
}
public void stop()
{
System.out.println("相机，停止工作了！");
}
public void cry()
{
}
public void Eee()
{
}
}
class Phone implements Usb
{
public void start()
{
System.out.println("手机，开始工作了！");
}
public void stop()
{
System.out.println("手机，停止工作了！");
}
}
class Computer
{
//开始使用use接口
public void useUsb(Usb usb)
{
usb.start();
usb.stop();
}
}

com.test3 / Test.java:

/*
* final修饰类
*/
package com.test3;
public class Test {
/**
* @param args
*/
public static void main(String[] args) {
Aaa aaa=new Aaa();
aaa.show();
Bbb bbb=new Bbb();
bbb.show();
}
}
//final修饰类，则表示该类不能被继承
//final class Aaa
class Aaa
{
int a=0;//如果不给初值，a=? ,在类中的成员变量最好赋个初值
//圆周率不希望被别人改,加final修饰
//如果一个变量用final修饰，则在定义时必须被初始化，而且后面不能改
final float rate_aaa_bbb=3.1415926f;
//给方法用final修饰，则表示不可以被修改，不可被覆盖
final public void sendMes()
{
System.out.println("发送消息");
}
public void show()
{
System.out.println("a="+this.a);
}
}
class Bbb extends Aaa
{
public Bbb()
{
a++;
//rate_aaa_bbb++; //因为rate_aaa_bbb为final类型
}
/*
public void sendMes()
{
System.out.println("发送消息");
}
*/
}
interface Fish
{
//该方法实现******
public void swimming();
}
interface Bird
{
public void fly();
}
class Monkey
{
int name;
//跳
public void jump()
{
System.out.println("猴子会跳");
}
}
class LittleMonkey extends Monkey implements Fish,Bird
{
@Override
public void swimming() {
}
@Override
public void fly() {
}
}

com..test3 / Mty99.java:

/*
99乘法表
*/
package com.test3;
public class Mty99
{
public static void main(String [] args)
{
for(int i=1;i<=9;i++)
{
for(int j=1;j<=i;j++)
{
if(i==3&&j==3||i==4&&j==3)
System.out.print(" "+j+"*"+i+"="+i*j+" ");
else
System.out.print(j+"*"+i+"="+i*j+" ");
}
System.out.println("");
}
}
}

com.luowei / Demo1.java:

/*
* 功能：说明继承的必要性
*/
package com.luowei;
public class Demo1 {
/**
* @param args
*/
public static void main(String[] args) {
Pupil p1=new Pupil();
p1.printName();
}
}
//小学生类
class Pupil extends Stu
{
/*
//定义成员属性
private int age;
private String name;
private float fee;
*/
//交学费
public void pay(float fee)
{
this.fee=fee;
}
}
//幼儿
class Kid extends Pupil
{
}
//中学生
class MiddleStu extends Stu
{
/*
//定义成员属性
private int age;
private String name;
private float fee;
*/
//交学费
public void pay(float fee)
{
this.fee=fee*0.8f;
}
}
//大学生生
class CloStu extends Stu
{
/*
//定义成员属性
private int age;
private String name;
private float fee;
*/
//交学费
public void pay(float fee)
{
this.fee=fee*0.1f;
}
}
//将学生的共同属性抽象出来，做一个父类
class Stu
{
protected int age;
public String name;
public float fee;
public void printName()
{
System.out.println("名字："+this.name);
}
//如果不希望子类继承某个属性或方法，则将其显示声明为私有
}

com.luowei / Demo2.java:

package com.luowei;
import javax.swing.*;
public class Demo2 extends JFrame {
public static void main(String [] args)
{
//Demo2 demo2=new Demo2();
Abc abc1=new Abc();
System.out.println(abc1.getMax(4,1.2f));
}
/*
public Demo2()
{
this.setVisible(true);
this.setSize(200,200);
}
*/
}
class Abc
{
//返回较大的整数
public int getMax(int i,int j)
{
if(i>j)
{
return i;
}
else
{
return j;
}
}
public float getMax(float a,float b)//重载，参数类型不同
{
if(a>b)
{
return a;
}
else
{
return b;
}
}
//如果只是返回类型不同，是不能构成重载的
/*
public double getMax(float a,float b)//重载，参数类型不同
{
if(a>b)
{
return a;
}
else
{
return b;
}
}
*/
//如果只是控制访问修饰符号不一样，也不能构成重载
/*
protected float getMax(float a,float b)//重载，参数类型不同
{
if(a>b)
{
return a;
}
else
{
return b;
}
}
*/
}

com.luowei / Demo3.java:

package com.luowei;
public class Demo3 {
public static void main(String [] args)
{
//创建一只猫
Cat cat1=new Cat();
cat1.cry();
Dog dog1=new Dog();
dog1.cry();
}
}
class Animal
{
int age;
String name;
//都会叫
public void cry()
{
System.out.println("是个动物，不知道怎么叫唤");
}
}
//猫猫类
class Cat extends Animal
{
//覆盖就是将父类的方法再重新写一遍，如下边的cry()方法
public void cry()
{
System.out.println("猫猫叫！");
}
}
//狗类
class Dog extends Animal
{
public void cry()
{
System.out.println("汪汪叫！");
}
}

com.luowei / Demo4.java:

/*
* 功能：约瑟夫环，数到m的小孩出圈
*/
package com.luowei;
public class Demo4 {
/**
* @param args
*/
public static void main(String[] args) {
CycLink cyclink=new CycLink();
cyclink.setLen(5);
cyclink.createLink();
cyclink.setK(2);//设置从第几个人开始数数
cyclink.setM(2);//设置的数m
cyclink.show();
cyclink.play();
}
}
class Child
{
int no;
Child nextChild;
public Child(int no)
{
//给一个编号
this.no=no;
}
}
class CycLink
{
//先定义一个指向链表第一个小孩的引用
//指向第一个小孩的引用，不能动
Child firstChild=null;
Child temp=null;
int len=0;//表示共有多少个小孩
int k=0;
int m=0;
//设置小孩的个数
public void setLen(int len)
{
this.len=len;
}
//设置m
public void setM(int m)
{
this.m=m;
}
//设置从第几个人开始数数
public void setK(int k)
{
this.k=k;
}
//开始数数
public void play()
{
Child temp=this.firstChild;
//1.先找到开始数数的人
for(int i=1;i
{
//因为自己数一下，再找到下一个人，所以将i
temp=temp.nextChild;
}
while(this.len!=1)
{
Child temp2=temp;//用来存放第m-1个孩子
//2.数m下
for(int j=1;j
{
if(j==m-1)
{
temp2=temp;
}
temp=temp.nextChild;
}
/*
//找到要出圈的前一个小孩
Child temp2=temp;
while(temp2.nextChild!=temp)
{
temp2=temp2.nextChild;
}
*/
//3.将数到m的小孩，退出圈
temp2.nextChild=temp.nextChild;
//让temp指向下一个数数的小孩
temp=temp.nextChild;
this.len--;
}
//最后一个小孩子
System.out.println("最后出圈："+temp.no);
}
//初始化环形链表
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.nextChild=this.firstChild;
}
else//创建中间小孩
{
//继续创建小孩子
Child ch=new Child(i);
temp.nextChild=ch;
temp=ch;
}
}
}
}
//打印该环形链表
public void show()
{
//定义一个跑龙套
Child temp=this.firstChild;
do
{
System.out.print(temp.no+" ");
temp=temp.nextChild;//指到下一个
}while(temp!=this.firstChild);
}
}

com.luowei / Demo5.java:

/*
* 功能：多态的应用
*/
package com.luowei;
public class Demo5 {
/**
* @param args
*/
public static void main(String[] args) {
/*
Cat2 cat=new Cat2();
cat.cry();
Dog2 dog=new Dog2();
dog.cry();
*/
/*
Animal2 an=new Cat2();//多态的应用，创建Animal引用an，在这an是猫
an.cry();//通过Animal中的覆盖cry()方法可以实现多态
an=new Dog2();//利用多态性，使an的状态成为狗
an.cry();
//用一种引用可以管理很多的实例
*/
Master master=new Master();
master.feed(new Dog2(), new Bone());
master.feed(new Cat2(), new Fish());
}
}
//动物类Animal
class Animal2
{
String name;
int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//动物会叫
public void cry()
{
System.out.println("不知道怎么叫");
}
//方法覆盖(重写)的作用：
//1.可以实现多态，实现一个父类引用管理多个子类实例，呈现多种状态
//2.可以具体化子类行为。
//动物可以吃东西
public void eat()
{
System.out.println("不知道吃什么");
}
}
class Dog2 extends Animal2
{
//狗叫
public void cry()
{
System.out.println("汪汪叫");
}
//狗吃
public void eat()
{
System.out.println("狗喜欢吃骨头");
}
}
class Cat2 extends Animal2
{
//猫自己叫
public void cry()
{
System.out.println("猫猫叫");
}
//猫吃东西
public void eat()
{
System.out.println("猫喜欢吃鱼");
}
}
//食物
class Food
{
String name;
public void showName()
{
}
}
//鱼类
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(Animal2 an,Food f)
{
an.eat();
f.showName();
}
}