文件结构
Java访问修饰符
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<k;i++)
{
//因为自己数一下，再找到下一个人，所以将i<k
temp=temp.nextChild;
}
while(this.len!=1)
{
Child temp2=temp;//用来存放第m-1个孩子
//2.数m下
for(int j=1;j<m;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();
}
}
分享到：
发表评论
-
Java连接sql2005数据库三步曲
2012-12-27 10:48 686one、two、three 导入java包 import ja ... -
主题：Java面试122题 .
2012-12-27 10:17 8512012-06-05 09:17 592人阅读 ... -
Java六大必须理解的问题
2012-12-27 10:17 4812012-05-24 11:39 793人阅读 评论(6) 收 ... -
多线程知识点整理 .
2012-12-27 10:17 549基本概念 多线程程序 ... -
数据连接池的基本实现 .
2012-12-26 13:20 8251、 实现途径： 编写JdbcPool implemen ... -
java 常用三大集合类
2012-11-23 11:07 13752一、Set集合，其主要实现类有HashSet、TreeSet。 ... -
Java笔记9(Java网络编程)
2012-10-16 14:39 702Java基础9 Java基础9 1 文件结构 ... -
Java笔记8(jdbc-odbc、jdbc、JTable使用、Min版学生管理系统)
2012-10-16 14:34 1405Java基础8 Java基础8 1 文件结构 ... -
swing编程实现闪屏登录效果
2012-09-18 12:07 27061、先写一个闪屏类 package com.mhl.Tools ... -
paint和paintComponent方法的关系
2012-09-18 09:50 911关键词:swing,paint,paintComp ... -
Java笔记7(IO操作、图片拷贝、记事本、测试声音、坦克大战)
2012-08-23 15:05 1017File类的基本用法_Demo12_1.java /* ... -
Java笔记6(多线程、机票售票系统、坦克大战)
2012-08-23 14:39 1579多线程Demo10_1.java /* * 演 ... -
Java笔记5(java绘图原理、事件处理机制、监听器、坦克大战)
2012-08-23 14:30 2820java绘图原理Demo9_1.java /* ... -
java中equals和==的区别
2012-08-17 10:33 17506ava中equals和==的区别 值类型是存储在内存中的堆栈（ ... -
Java笔记4(布局管理器、常用组件、qq聊天界面、记事本)
2012-08-13 14:12 3371文件结构 布局管理器Demo8_1.java pa ... -
Java笔记3(泛型、异常、成绩评分程序)
2012-08-09 10:31 1018文件结构 泛型与异常 异常 Class7b / c ... -
Java笔记2(数组、排序、查找、集合类、移位)
2012-08-09 10:18 1728文件结构 Class5 / com.t ...
相关推荐
封装继承多态总结
这是关于C#封装继承多态的一个简单的例子，对于深入学习C#中封装继承多态将很有帮助！
java面向对象三要素封装继承和多态源码java面向对象三要素封装继承和多态源码java面向对象三要素封装继承和多态源码java面向对象三要素封装继承和多态源码java面向对象三要素封装继承和多态源码java面向对象三要素...
安老师 的一个例子，c++ 的封装继承多态例子
Educoder题目：Java面向对象 - 封装、继承和多态的综合练习答案解析
1、实验名称：类的继承、多态的应用 2、代码内容：学生管理类 3、【实验目的】 （1）进一步熟悉抽象类和抽象方法的定义 （2） 进一步掌握集成和多态的实现方式。
java基础_继承封装 多态，概念的梳理，对初学者很有帮助，看一遍就清楚了
Java封装继承多态实例以及文件流操作，自己整理的东西，用了单态模式实现了多态，并且贯彻了OOP思想，用到了文件流的写入与读取，希望对大家有帮助
JAVA面向对象基础测试题-继承-封装-多态等测试题.docx
python封装继承多态笔记，python封装继承多态笔记，python封装继承多态笔记适合初学者学习！
java封装 继承与多态 程序设计 类与对象
实现重载（overload）和重写（override） 调用中用到多态，向上转换，强制转换 所有被创建的类，都各自创建两个实现接口 最底层的类中创建内部类，并在外部类中调用内部类的方法
第3章 类的封装、继承和多态 第4章 接口、内部类和Java API基础 第5章 异常处理 第6章 图形用户界面 第7章 多线程 第8章 Applet应用程序 第9章 输入/输出流和文件操作 第10章 网络通信 第11章 数据库应用 第12章 ...
javascript中如何实现封装,继承和多态
西南科技大学Java程序设计与实践 实验三 类的继承与多态的应用 一、实验目的： 1、练习类的继承与多态设计过程； 2、练习面向对象的图形用户界面设计、事件设计方法。 二、实验内容： 1、利用多态性编程，创建一个 ...
抽象类_接口_多态_继承整合案例.。
前端模块化脚手架，可实现类似java的封装继承多态特性
Java SE编程入门教程 java封装继承多态（共56页）.pptx Java SE编程入门教程 java集合（共38页）.pptx Java SE编程入门教程 java接口（共21页）.pptx Java SE编程入门教程 java类和对象方法以及包的使用（共56页）....
jave面向对象特性继承、封装、多态的实验报告，jave重要实验。