「java像素继承」java像素类

今天给各位分享java像素继承的知识，其中也会对java像素类进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、java中声明Point类表示一个点的x轴和y轴坐标，声明若干get（）和set（）方法获得？
• 2、java继承调用
• 3、java 类的继承
• 4、JAVA中什么是继承？
• 5、java里面获得图像像素后怎么做dct变换

java中声明Point类表示一个点的x轴和y轴坐标，声明若干get（）和set（）方法获得？

用JAVA声明类和接口，声明像素类Pixel继承Point类，因为像素是一个带颜色的坐标点。

具体代码：

public class Point implements Cloneable

{

private int x;

private int y;

// 不带参数的构造方法

public Point()

{

this(0, 0);

}

// 带参数的构造方法

public Point(int x, int y)

{

this.x = x;

this.y = y;

}

// 拷贝方法

@Override

protected Object clone() throws CloneNotSupportedException

{

return super.clone();

}

//set 和 get 方法

public int getX()

{

return x;

}

public void setX(int x)

{

this.x = x;

}

public int getY()

{

return y;

}

public void setY(int y)

{

this.y = y;

}

//move()方法

public void move(int x,int y)

{

this.x = this.x + x;

this.y = this.y + y;

}

}

java继承调用

1，java的继承，调用时两个知识点

2，java继承，只能单继承，继承后如果父类含有抽象方法则实现父类的抽象方法

3，java调用，需要new实例

4，继承可以直接用父类的方法，属性，调用需要new对象才能使用

5，继承就像父子关系，而调用就像借别人家的东西使用一样，继承是父亲有的儿子必须有，调用时借来的东西有什么用什么。

java 类的继承

JAVA允许类继承，而且是单继承，这是一个子类只能有一个直接的父类（基类），但是这个子类的父可能是另一个子类，如A扩展B，B扩展C，A意志有一个可见的构件和方法C，这是类继承及物。然而，C ++，让子类可以有多个基类继承的许多能力，如A类：公共B，公共C，虽然它可以更好地描述展示世界，也更复杂的问题。 JAVA类的继承通过了C ++多重继承功能的实现。 java的继承可以发生在子类和父类和C ++这是一个不同的点吧。所谓继承一个类继承另一个类，有父类（C ++的基类）的方法可见可见成员，继承只能发生在一个子类和超

JAVA中什么是继承？

继承在本职上是特殊一般的关系，即常说的is-a关系。子类继承父类，表明子类是一种特殊的父类，并且具有父类所不具有的 一些属性或方法。

1.Java继承的语法格式:

Java继承的关键字是：extends

public class 子类名 extends 父类名{...}

如： public class UNStudent extends Student {...} 注：1.子类又称超类，拓展类 ;父类又称基类。

2.Java中类的继承只能是单继承(单根继承)，即一个类只能继承一个父类，但是一个类可以由多个类来继承它。

3.Java会给每一个没有设置父类的类，自动添加一个父类就是Object 。

扩展资料：

一、子类继承父类的结果

1.子类继承父类后，继承到了父类所有的属性和方法。 注：是所有。

2.子类可调用的方法也要看情况而定：

子类和父类在同一个包下时 “子类和子类的对象”可以调用父类的默认的，受保护的，公有的属性以及方法。

子类和父类在不同的包下时,在子类中可以调用受保护的，公有的属性以及方法,而子类的对象可以调用受保护的，公有的属性以及方法。

二、方法的重写

1.当子类和父类都有某种方法，而子类的方法更加要求细致，或者实现功能不同，就需要方法的重写。

2.重写条件

①必须要存在继承关系;只有继承之间的关系才能有方法的重写

②方法的返回值类型，方法名，参数个数，参数类型，参数顺序，必须要完全一致;

如：父类中方法 public void play (int n ; String s){方法体1...}

重写后的子类方法public void play(int n ; String s){方法体2...}

3.子类重写方法时的访问修饰符可以大于或者等于父类方法的访问修饰符。

4.重写后的方法会被优先调用。

三、自动转型

自动转型的实现要求有继承关系

格式如下：父类名 对象名 = new 子类构造方法;

如：Student stu = new UNStudent;

而强制转型格式如下：子类名 对象名 = (子类名)父类对象名

如：UNStudent un = (Student)stu;

自动转型可以拓宽方法的作用访问域

在使用自动转型后，子类自己定义的方法是不能在自动转型后执行;

原因是因为Java的编译机制，它会优先判断父类中是否存在该方法，如果存在则通过编译，如果不存在则报错。

第二种自动转型：转型后只需要不同类的不同对象调用想吐的方法，很方便!

/**访问修饰符 返回值数据类型 方法名(父类类型 参数名,...){

调用方法。

}

父类名 对象名 = new 子类名;

子类名 对象名 = new 子类名;

方法名(对象名);

*/

比如拿到驾驶证为A2的人，可以驾驶重型货车，当然也可以驾驶大型货车，中型货车，小型货车，小客车，小轿车，摩托车... 可以选择第二种自动转型的方法，便于调用同一个方法。

自动转型好处：1.减少冗余代码;2.在方法设置参数时，扩大访问范围。

四、多态

多态是由方法重载，继承，方法重写，自动转型等技术的组合。

五、为什么需要继承?

1.提高代码的重用性。

2.提高程序的扩展性。

参考资料：

JAVA继承总结

java里面获得图像像素后怎么做dct变换

private void setAlpha(ByteArrayOutputStream os) {

try {

ImageIcon imageIcon = new ImageIcon(os.toByteArray());

BufferedImage bufferedImage = new BufferedImage(imageIcon.getIconWidth(),imageIcon.getIconHeight()

, BufferedImage.TYPE_4BYTE_ABGR);

Graphics2D g2D = (Graphics2D) bufferedImage.getGraphics();

g2D.drawImage(imageIcon.getImage(), 0, 0,

imageIcon.getImageObserver());

//循环每一个像素点，改变像素点的Alpha值

int alpha = 100;

for (int j1 = bufferedImage.getMinY(); j1 bufferedImage.getHeight(); j1++) {

for (int j2 = bufferedImage.getMinX(); j2 bufferedImage.getWidth(); j2++) {

int rgb = bufferedImage.getRGB(j2, j1);

rgb = ( (alpha + 1) 24) | (rgb 0x00ffffff);

bufferedImage.setRGB(j2, j1, rgb);

}

}

g2D.drawImage(bufferedImage, 0, 0, imageIcon.getImageObserver());

//生成图片为PNG

ImageIO.write(bufferedImage, "png", new File(图片路径));

}

catch (Exception e) {

e.printStackTrace();

}

}

使用JAVA对图片进行效果变换（第二幅图覆盖第一幅图的像素并显示）

一提到JAVA，谈论最多的就是JSP/SERVLET/J2EE之类的，但对于用JAVA对图片进行效果变换，到论坛里看了看，关于这方面的话题并不多，网上关于图像效果处理的文章也并不丰富，于是在自己摸索了几天，并且参考了AnfyJava(专业级的JAVA效果生成器)后，我用轻量级控件写了一个(AnfyJava继承的是Applet，Applet是java.awt包中的，属于重量级控件，SUN现在推荐使用swing来编写图形程序，因此，我用的是JApplet)。

其实，用JAVA做图像效果和其它语言在本质上并没有什么区别，只不过在实现起来有所不同罢了，下面我就把我在项目中处理的经验与大家分享一下吧。

图像的变换，实际上就是把两幅图片的内容进行某些运算，生成新的图像，然后显示出来，最终实现从一幅图片到另一幅图片的过度效果。变换的具体过程如下：

在上面的过程中，图片A和B的尺寸最好保持一致，如果不一致的话，可能要做一些额外的处理，在此，我选用的图片A和B的尺寸是一致的。

首先，我们将其当作一个Applet来写，由于Applet的局限性，不可以直接使用File类来读取图像文件，因此，我们只能通过如下方法来获取图像文件。

URLClassLoader urlLoader = (URLClassLoader)this.getClass().getClassLoader();

URL url = urlLoader.findResource("imagea.gif");

Image image = Toolkit.getDefaultToolkit().getImage(url);

当我们获得了图像后，可以通过java.awt.image.PixelGrabber包中的PixelGrabber方法来将图像中的像素信息完全读取出来，其用法如下：

PixelGrabber(Image img, int x, int y, int w, int h, int[] pix, int off, int scansize)

其中img是要读取的图像，x/y是要读取图像中的左上角坐标，w/h分别是从x/y开始起的距离，其实x,y,w,h就是一个矩形，pix是保存像素的数组，off是读取图像时开始的位置，scansize是指扫描的宽度，一般来说和w相等。

int width = image.getWidth();

int height = image.getHeight();

int size = width * height;

int[] pixels = new int[size];

pixelgrabber = new PixelGrabber(image, 0, 0, width, height, pixels, 0, width);

try {

pixelgrabber.grabPixels(); //读取像素入数组

}

catch (InterruptedException _ex) {}

由于像素信息是由alpha,red,green,blue组成的，其格式为

因此，我们可以将颜色分解成单独的RGB信息

int alpha = (pixel 24) 0xff;

int red = (pixel 16) 0xff;

int green = (pixel 8) 0xff;

int blue = (pixel) 0xff;

假如要实现显示图片A后，图片B由上至下展开，则可以每次将图片A中的一行像素替换为B中的相应行，然后生成新的像素信息：

图像A的像素数组 图像B的像素数组

old = pixelA; //保存图片A的像素信息

oldR = redA; //保存图片A的R信息

oldG = greenA; //保存图片A的G信息

oldB = blueA; //保存图片A的B信息

for (int i = 0; i width; i++) {//line为行数

oldR[line * width + i] = redA [line * width + i];

oldG[line * width + i] = greenA [line * width + i];

oldB[line * width + i] = blueA [line * width + i];

old[line * width + i] = oldR[line * width + i] 16 + oldG[line * width + i] 8 + oldB[line * width + i];

}

当生成新的像素信息后，可以通过java.awt.image.MemoryImageSource包中的MemoryImageSource(int w, int h, ColorModel cm, int[] pix, int off, int scan)方法将像素数组对应到图像，并且可以用newPixels()方法来生成新的图像(具体用法可以参考JAVA API DOC)。

memoryimagesource = new MemoryImageSource(imageWidth, imageHeight,

new DirectColorModel(24, 0xff0000, 0x00ff00, 0x0000ff), blocks, 0, imageWidth);

//检查java版本

String javaVersion;

try {

javaVersion = System.getProperty("java.version");

}

catch (SecurityException _ex) {

javaVersion = "unk";

}

if (!javaVersion.startsWith("1.0")) { //jdk1.1以上的版本才支持此方法

try {

memoryimagesource.setAnimated(true);

memoryimagesource.setFullBufferUpdates(true);

imageBuf = createImage(memoryimagesource);

memoryimagesource.newPixels();//生成新的图像

}

catch (NoSuchMethodError _ex) {

System.out.println("unknow java version!");

}

}

到此，新的图像已经产生，只需要输出到屏幕即可。

在此，需要注意以下几个问题：

1、由于Applet读取的图像文件可以比较大，对于速度较慢的网络，可能会造成图像未读取完全就开始进行变换，因此，建议使用MediaTracker方法来保证图像能被顺利载入。

2、 在显示的时候，为了避免闪烁，可以采用双缓冲的方法。

3、 由于在某此高速计算机上，生成新的像素可以非常快，为了避免速度过快而造成效果并不明显，可以加以适当的延时处理。

4、 为了保证效果的平滑，我们特地开辟了非常大的数组来保存像素/RGB信息，这是以空间换时间的做法。

完整的源程序附下(在jdk1.4/2k Server/RedHat9下运行通过，所用机器为P4 2.4G/512M)

package pic;

import java.awt.*;

import java.io.*;

import java.net.*;

import java.awt.event.*;

import java.awt.image.*;

import javax.swing.*;

public class effect

extends JApplet

implements Runnable {

//定义变量

Toolkit toolkit;

int totalBlocks = 0; //图像被分解成的块数，默认为 宽X高

int[] blocks; //保存块数的信息

Image[] bufferImage = new Image[2]; //屏幕上的图形缓冲

VolatileImage offScreenImage;

Image imageBuf; //保存图片缓冲区内容

Graphics2D offScreenGraphics;

Thread thread;

MediaTracker mediaTracker;

boolean[] isImageReady; //图片是否已经装载

MemoryImageSource memoryimagesource;

int imageWidth, imageHeight; //图像的宽及高

int[] pixelA, pixelB;

int[] redA, greenA, blueA, redB, greenB, blueB;

public effect() throws HeadlessException {

bufferImage[0] = getImage("a.jpg");

bufferImage[1] = getImage("b.jpg");

if ( (bufferImage[0].getWidth(this) != bufferImage[1].getWidth(this)) ||

(bufferImage[0].getHeight(this) != bufferImage[1].getHeight(this))) {

System.out.println("图像尺寸不一致！");

return;

}

toolkit = getToolkit();

imageWidth = bufferImage[0].getWidth(this);

imageHeight = bufferImage[0].getHeight(this);

totalBlocks = imageWidth * imageHeight; //计算分解的块数

blocks = new int[totalBlocks];

pixelA = new int[totalBlocks];

pixelB = new int[totalBlocks];

redA = new int[totalBlocks];

greenA = new int[totalBlocks];

blueA = new int[totalBlocks];

redB = new int[totalBlocks];

greenB = new int[totalBlocks];

blueB = new int[totalBlocks];

GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();

GraphicsDevice gd = ge.getDefaultScreenDevice();

GraphicsConfiguration gc = gd.getDefaultConfiguration();

offScreenImage = gc.createCompatibleVolatileImage(imageWidth, imageHeight); //创建图像缓冲

offScreenGraphics = offScreenImage.createGraphics(); //取得缓冲的graphics对象

}

public void init() {

getImagePixels(bufferImage[0], pixelA);

getImagePixels(bufferImage[1], pixelB);

for (int i = 0; i totalBlocks; i++) {

blocks[i] = pixelA[i]; //保存图像A的像素信息

redA[i] = pixelA[i] 0xff0000; //保存图像B的red值

greenA[i] = pixelA[i] 0x00ff00; //保存图像B的green值

blueA[i] = pixelA[i] 0x0000ff; //保存图像B的blue值

redB[i] = pixelB[i] 0xff0000; //保存图像B的red值

greenB[i] = pixelB[i] 0x00ff00; //保存图像B的green值

blueB[i] = pixelB[i] 0x0000ff; //保存图像B的blue值

}

prepareImagePixels(); //将像素信息还原为图像

}

public void run() {

//检查java版本

String javaVersion;

try {

javaVersion = System.getProperty("java.version");

}

catch (SecurityException _ex) {

javaVersion = "unk";

}

if (javaVersion.startsWith("1.0")) {

System.out.println("require java 1.1 or later version!");

return;

}

try { //暂停3秒钟后等待效果开始

thread.sleep(3000l);

}

catch (InterruptedException ex1) {

}

int line = 0;

Thread currentThread = Thread.currentThread();

while (line imageHeight thread == currentThread) {

for (int i = 0; i imageWidth; i++) {

int offset = line * imageWidth + i;

blocks[offset] = pixelB[offset]; //与下一被注释的语句作用相同

//blocks[offset] = redB[offset] | greenB[offset] | blueB[offset];

}

memoryimagesource.newPixels(); //生成新的图像

line++;

repaint();

//适当延时

try {

thread.sleep(20l);

}

catch (InterruptedException ex) {

}

}

}

public void paint(Graphics g) {

if (offScreenGraphics != null) { //保证在destory()时不引发异常

offScreenGraphics.drawImage(imageBuf, 0, 0, this);

g.drawImage(offScreenImage, 0, 0, this);

}

}

public void start() {

if (thread == null) {

thread = new Thread(this);

thread.start();

}

}

public void stop() {

thread = null;

}

public final void update(Graphics g) {

paint(g);

}

public void destroy() {

if (offScreenImage != null) {

offScreenImage.flush();

}

offScreenImage = null;

if (offScreenGraphics != null) {

offScreenGraphics.dispose();

}

offScreenGraphics = null;

System.gc();

}

Image getImage(String filename) {

URLClassLoader urlLoader = (URLClassLoader)this.getClass().getClassLoader();

URL url = null;

Image image = null;

url = urlLoader.findResource(filename);

image = Toolkit.getDefaultToolkit().getImage(url);

MediaTracker mediatracker = new MediaTracker(this);

try {

mediatracker.addImage(image, 0);

mediatracker.waitForID(0);

}

catch (InterruptedException _ex) {

image = null;

}

if (mediatracker.isErrorID(0)) {

image = null;

}

return image;

}

private boolean getImagePixels(Image image, int pixels[]) {

PixelGrabber pixelgrabber = new PixelGrabber(image, 0, 0, imageWidth,

imageHeight, pixels,

0, imageWidth);

try {

pixelgrabber.grabPixels();

}

catch (InterruptedException _ex) {

return false;

}

return true;

}

void prepareImagePixels() {

memoryimagesource = new MemoryImageSource(imageWidth, imageHeight,

new DirectColorModel(24, 0xff0000,

0x00ff00, 0x0000ff), blocks, 0, imageWidth);

try {

memoryimagesource.setAnimated(true);

memoryimagesource.setFullBufferUpdates(true);

imageBuf = createImage(memoryimagesource);

memoryimagesource.newPixels(); //生成新的图像

}

catch (NoSuchMethodError _ex) {

}

}

public int getWidth() {

return imageWidth;

}

public int getHeight() {

return imageHeight;

}

public static void main(String args[]) {

JFrame frame = new JFrame("Demo");

effect e = new effect();

e.init();

e.start();

frame.getContentPane().setLayout(new BorderLayout());

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

frame.setResizable(false);

frame.getContentPane().add(e);

frame.setSize(new Dimension(e.getWidth() + 6, e.getHeight() + 20));

Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();

Dimension frameSize = frame.getSize();

frame.setLocation( (screenSize.width - frameSize.width) / 2,

(screenSize.height - frameSize.height) / 2);

frame.show();

}

}

新建一个HTML文件，加入以下语句可作为Applet(其中width/height分别是图片的高和宽)：

作为应用程序运行的时候，在命令行输入：

java pic.effect

关于java像素继承和java像素类的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。