Java学习04-接口，多态，内部类，匿名内部类，Object类

最新推荐文章于 2024-11-17 21:07:59 发布

nuddlesW

最新推荐文章于 2024-11-17 21:07:59 发布

阅读量682

点赞数

文章标签： java 语言

本文链接：https://blog.csdn.net/nuddlesW/article/details/42080015

版权

1.接口

接口：初期理解，可以认为是一个特殊的抽象类

当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。

class用于定义类

interface 用于定义接口。

接口定义时，格式特点：

接口中常见定义：常量，抽象方法。
接口中的成员都有固定修饰符。
常量：public static final
方法：public abstract
记住：接口中的成员都是public的这此修饰符都可以省略，最好写全

接口可以多重继承

接口：是不可以创建对象的，因为有抽象方法。

需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。

否则子类是一个抽象类。

接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。

基本功能和扩展功能，接口实现扩展功能

interface Smoking{
	void smoke();
}

class Student{
	String name;
	Student(String name){
		this.name =name;
	}
	void study(){
		System.out.println("studying");
	}
}

class BaseStudent extends Student implements Smoking{
	BaseStudent(String name){
	 super(name);	
	}
	public void smoke(){
		System.out.println("smoking");
	}
}

public class InterfaceTest{
	public static void main(String[] args){
		BaseStudent bs = new BaseStudent("nuddlesW");
		bs.study();
		bs.smoke();
		}
	}

2.多态：

可以理解为事物存在的多种体现形态。

人：男人，女人

动物：猫，狗。

猫 x = new 猫();

动物 x = new 猫();

多态的体现

父类的引用指向了自己的子类对象。
父类的引用也可以接收自己的子类对象。

多态的前提

必须是类与类之间有关系。要么继承，要么实现。
通常还有一个前提：存在覆盖。

多态的好处

多态的出现大大的提高程序的扩展性。

多态的弊端：

提高了扩展性，但是只能使用父类的引用访问父类中的成员。

多态的应用

/*
动物，
猫，狗。
*/
abstract class Animal{
         abstract void eat();
 }
 
class Cat extends Animal{
   public void eat(){
             System.out.println("吃鱼");
   }
   public void catchMouse(){
             System.out.println("抓老鼠");
   }
}
 
class Dog extends Animal{
   public void eat(){
             System.out.println("吃骨头");
   }
   public void kanJia(){
             System.out.println("看家");
  }
}


  class Pig extends Animal{
   public void eat(){
             System.out.println("饲料");
   }
   public void gongDi(){
             System.out.println("拱地");
   }
}
  
class DuoTaiDemo{
   public static void main(String[] args){
        
             Cat c1 = new Cat();
             function(c1);

             function(new Dog());
             function(new Pig());                 
            function(new Cat());         
   }
   public static void function(Animal a)//Animal a = new Cat();{
   //父类的引用指向子类
             a.eat();
             //a.catchMouse();
   }
}

3.转型

animal a = new Cat();//类型提升。向上转型。

a.eat();

如果想要调用猫的特有方法时，如何操作？

强制将父类的引用。转成子类类型。向下转型。

animal a =new cat();

Cat c = (Cat)a;

c.catchMouse();

千万不要出现以下这样的操作，就是将父类对象转成子类类型。

Animal a = new Animal();

Cat c = (Cat)a;

我们能转换的是父类应用指向了自己的子类对象时，该应用可以被提升，也可以被强制转换。

多态自始至终都是子类对象在做着变化。

if(a instanceof 类名) 关键字instanceof 用来判断是否属于某类

4.封闭功能

学会使用类来封装功能，即该类中没有成员变量，只有封装方法如

class Function

{

public void function(Student s)

{

s.run()

}

5.多态中成员函数的特点：

方法

在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。
在运行时期：参阅对象所属的类中是否有调用的方法。
简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。

在多态中，成员变量的特点：

无论编译和运行，都参考左边(引用型变量所属的类)。

在多态中，静态成员函数的特点：

无论编译和运行，都参考做左边。

class Fu{
	 int num = 5;
	void method1(){
		System.out.println("fu method_1");
	}
	void method2(){
		System.out.println("fu method_2");
	}
	 void method4(){
		System.out.println("fu method_4");
	}
}


class Zi extends Fu{
	 int num = 8;
	void method1(){
		System.out.println("zi method_1");
	}
	void method3(){
		System.out.println("zi method_3");
	}

	void method4(){
		System.out.println("zi method_4");
	}
}
class  DuoTaiDemo4{
	public static void main(String[] args) {
		Fu f = new Zi();
		System.out.println(f.num);
		f.method4();

		Zi z = new Zi();
		z.method4();
		System.out.println(z.num);

	}
}

运行结果：成员变量不管有没有static, 都是5，8

方法，如果有static 就是fu method_4

zi method_4

如果没有static就都是 zi method_4

练习：

/*
要求：模仿电脑主板工作过程
思路：定义接口，主板连接相应接口，既能工作。
*/

interface Pci
{
	void open();
	void close();
	}
	
class SoundCard implements Pci	
{
	public void open()
	{
			System.out.println("soundcard start");
		}
	public void close()
		{
			System.out.println("soundcard close");
			}
	}
	

class NetCard implements Pci	
{
	public void open()
	{
			System.out.println("netcard start");
		}
		public void close()
		{
			System.out.println("netcard close");
			}
	}
	
class Board
{
	public void run(Pci p)
	{
		if(p != null)
		{
			p.open();
			p.close();
			}
		}
	}
	
public class Computer
{
	public static void main(String[] args)
	{
		Board b = new Board();
		b.run(new SoundCard());
		b.run(new NetCard());
		}
	}

-----------OUTPUT-----------
soundcard start
soundcard close
netcard start
netcard close

6.程序执行内部过程

JAVA语言中除基本类型之外的变量类型，都称之为引用类型。 JAVA中对象是通过引用reference对其操作的。新建对象时，引用类型的数据都是null，基本数据类型 int 是 0 string 是null boolean 是false (默认初始化) 方法：参数传递的值是值传递。局部变量必须初始化，成员变量会被系统默认初始化。

栈：自动分配连续的空间，后进先出，一般用来放置局部变量，数据使用完毕之后，会自动释放

堆：不连续，用来放置 new出来的对象，

堆中的数据都会有默认初始化值。引用类型的数据都是null，基本数据类型 int 是 0 string 是null boolean 是false (默认初始化)

方法区：属于堆的一部分，存放类的信息（代码）、static变量、常量池（字符串常量）等解析：

1、主函数中定义一个 int x=3; 主函数加载时，主函数就在内存中的栈中开辟一个空间，此空间中就会定义一个变量，并且赋值为3.

2、主函数中创建一个 int[] x=new int[3]; 左边 int[] x，在栈内存中定义了一个变量 x, new int[3],在堆内存中开辟了一个空间，每个在堆内存中存在的数据都会有一个地址值。 = 时，就将x的引用指向了new 对象在堆内存中的地址值。注：操作对象就是操作地址。

例子： //通过类加载器 Class LOader加载Student类，加载后，在方法区中就有了Student中的类的信息 Student s1=new Student(); s1.name="张三";

7.内部类：

内部类

讲一个雷定义在另一个类的里面，对立面那个类就叫做内部类，或者嵌套类。
特点，内部类可以直接访问外部类中的成员。包括私有成员。而外部类要访问内部类中的成员必须要建立内部类对象。

代码
class outer

   class inner
      
     void function(){}

   }

}
inner内部类。

访问规则：1.内部类可以直接访问外部类中的成员，包括私有。是因为内部类中持有了一个外部类的引用。格式：外部类名.this
         2.外部类要访问内部类，必须要建立内部类的对象。
         3.内部类作为外部类的成员 可以被私有化
如何直接访问内部类中的成员 function()
outer.inner  in=new outer().new inner();
   in.function();

访问格式：
1.当内部类定义在外部类的位置上的时候，而且非私有，可以在外部其他类中，可以直接建立内部类对象
  格式 外部类名.内部类名  变量名=外部类对象.内部类对象
       outer.inner  in=new outer().new inner();

2.当内部类在成员的位置上，就可以被成员修饰符所修饰。
  比如：private  static，
  当内部类被static修饰后，只能直接访问外部类中的static成员，出现了访问局限
  在外部其他类中，如何直接访问static内部类的非静态成员？
  new Outer.Inner().sunction();
  在外部其他类中，如何直接访问staic内部类的静态成员？
  outer.inner.function();
注意：当内部类中定义了静态成员，该内部类必须是static 的。
     当外部类中的静态方法访问内部类是，该内部类必须是静态的
内部类定义原则：
当描述事物中，事物的内部还有事物，该事物用内部类来描述。
因为内部事务在使用外部事物中的内容。

package nuddles.j2seDemo;

public class InnerDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
//		new Outer.Inner().info2();
//		System.out.println(Outer.Inner.name);
		new Outer().info();
		 Outer.Inner in = new Outer().new Inner();
		 in.info2();
//		new Outer().info();
	}

}


class Outer{
	private int num =7;
	public void info(){
		
		new Inner().info2();
	}
	class Inner{
		String name = "nuddles";
		public  void info2(){
			System.out.println(num+name);
		}
	}
}

内部类定义在局部时，

 
 不可以被成员修饰符修饰
可以直接访问外部类中的成员，因为还持有外部类中的引用。但是只能访问被final修饰的局部变量。

8.匿名内部类:

1，匿名内部类其实就是内部类的简写格式。

2，定义匿名内部类的前提：

	内部类必须是继承一个类或者实现接口。

3，匿名内部类的格式：  new 父类或者接口(){定义子类的内容}

4，其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。	可以理解为带内容的对象。

5，匿名内部类中定义的方法最好不要超过3个。

interface Demo  {
	public abstract void run();
}

class Wai{
	static int i = 9;
	static class Nei{
		static int y = 10;
		public  static void run( int x){
			i = x;
			System.out.println(i);
		}
	}
	public void fucntion(){
		new Demo(){
			int j = 9;
			public void run(){
				System.out.println(j);
			}
		}.run();
		// 匿名内部类实现了Demo接口
	}
	
}

class InnerTest{
	public static void main(String[] args) {
		 Wai.Nei.run(11);
		/*Wai w = new Wai();
		w.Nei().run(10);*/
		new Wai().fucntion();
	}
}

9.Object类

equals 方法：

其实和== 一样，比较的是引用地址是否一样，通常要复写，覆写要注意接收的类是object,然后判断，再向下转型

toString方法，返回值是：

getClass().getName() + '@' + Integer.toHexString(hashCode())

nuddlesW

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫