java进阶

最新推荐文章于 2024-05-23 20:31:41 发布

weixin_42675851

最新推荐文章于 2024-05-23 20:31:41 发布

阅读量120

点赞数

分类专栏： Java 文章标签： eclipse

本文链接：https://blog.csdn.net/weixin_42675851/article/details/119388565

版权

Java 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

10.6.abstract、interface

10.1继承

public class Extends {
/*继承：基本思想是基于某个父类进行扩展，得到一个新的子类。
 * 子类可以继承父类原有的属性和方法，也可以增加父类不具有的属性和方法，也可以重写某些方法。
 * 重写的方法不影响父类方法，如果想再调用父类方法基础上有所添加，可以super.父类方法+添加内容。
 * super可以用来调用父类的构造方法，成员属性，成员方法，this是本类调用
 * 一个类只可以有一个父类，可以用多重继承
 * 子类不仅会覆盖父类的方法，还会覆盖父类的属性，此时属性是同名字
 */
	public Extends() {//构造方法
		System.out.println("这是父类构造方法");
	}
	protected void doSomething() {//成员方法
		System.out.println("这是父类成员方法");
	} 
	//main方法要放在和文件名字相同的类里面
	public static void main(String[] args) {
		Extends2 a = new Extends2();//继承了构造方法
		a.doSomething();//重写
		a.doSomethingNew();//新增
//在实例化子类对象时，父类无参构造方法将会被自动调用，有参构造方法不能被自动调用		
//可用super显式调用父类构造方法		
	}
}
class Extends2 extends Extends {
	public Extends2() {//构造方法
		super();//调用父类构造方法
		super.doSomething();//调用父类成员方法			
	}
	public void doSomething() {//重写父类方法
		System.out.println("这是重写父类的子类成员方法");
	}
	public void doSomethingNew() {//新增方法
		System.out.println("这是新增的子类方法");
	}
}

10.2.Object

//java中所有的类都直接或间接的继承了java.lang.object类
/*
 * object是比较特殊的类，是所有类的父类，自定义的类也是继承于object类
 */
public class Object {

	public static void main(String[] args) {
		Object[] arr = new Object[4];
		
		arr[0] = new Object();
		arr[1] = new String("nihao");
		arr[2] = new Integer(10);
	
		for(Object obj:arr) {
			System.out.println(obj.getClass());//返回的是类的全名
			System.out.println(obj.toString());//返回字符串
			System.out.println(arr[0].equals(arr[2]));//比较两个对象是否相等，并非地址
		}
	}

}

10.3ClassCast

/*对象类型的转换 new 实例化对象，可以看做一个三角形，越靠下越抽象
 *向上转型： 实例化子类对象；                     （子类对象一定是父类对象的实例）家禽一定有鸭子
 * 调用父类方法（子类对象参数引用）；                  =   声明父类  对象 = new（调用）子类对象（）
 * 向下转型：实例化父类对象                         （父类对象不一定是子类对象的实例）鸭子不一定是家禽
 * 调用子类方法（父类对象参数引用）；
 * 执行向下转型前，要判断父类对象是否是子类对象的实例，
 * 若非，发生ClassCastException，类强制转换异常
 */
//判断对象类型  myobject instanceof exampleClass；是否是某类的实例，返回布尔值
//向下转型时使用
public class ClassCast {

	public ClassCast() {
		// TODO Auto-generated constructor stub
	}
        public static void main (String args[]) {
        	A a = new B();          //向上转型，通过子类去实例化父类
        	//向上转型时,父类只能调用父类方法或者子类覆写后的方法,
        	//而子类中的单独方法则是无法调用的.意义：实现某个方法的子功能  
        	a.print();
        	 if(a instanceof B)
             {
                     B b = (B)a;   //向下转型,通过父类实例化子类
                     b.funcB();    //调用B类独有的方法
             }
        	 A b = new A();
        	 b.print();//以不同类对象调用父类函数时，结果不同，体现了多态
        	
        }

}
class A {
    public void print() {
             System.out.println("A:print");
    }
   
}

class B extends A {
    public void print() {        
             System.out.println("B:print");
    }
    public void funcB() {
        System.out.println("funcB");
    }
}

10.4.MethodOverload

public class MethodOverload {
//方法重载：在同一个类中允许存在一个以上的同名方法，
	/*参数顺序不同，（int a, double b）与（double b， int a）
	 * 参数类型不同，（int a）与（double b）
	 * 参数个数不同，（int a）与(int...a)不定长参数                     构成重载
	 * 
	 * 方法重载使得方法以统一的名称被管理，程序代码更有条理
	
	 */
	public MethodOverload() {
		// TODO Auto-generated constructor stub
	}
	 public static void main(String[] args) {
	        MyClass t = new MyClass(3);
	        t.info();
	        t.info("重载方法");
	        //重载构造函数
	        new MyClass();//通过new关键字或者通过类名直接生成对象。
	       System.out.println(t.info(1,2,3,4,5));
	       System.out.println(t.ab(1,2,3,4,5));
	    }
}
class MyClass {
    int height;
    MyClass() {
        System.out.println("无参数构造函数");
        height = 4;
    }
    MyClass(int i) {
        System.out.println("房子高度为 " + i + " 米");
        height = i;
    }
    void info() {
        System.out.println("房子高度为 " + height + " 米");
    }
    void info(String s) {
        System.out.println(s + ": 房子高度为 " + height + " 米");
    }
    int info(int...a){//a是数组，以数组长度为循环条件
    	int s = 0;
    	for(int i= 0;i<a.length;i++)
    		s+=i;
    	return s;
    }
    int ab(int...a){//a是数组，以数组长度为循环条件,求参数和
    	int s = 0;
    	for(int i= 0;i<a.length;i++)
    		s+=a[i];
    	return s;
    }
}

10.5.DuoTai

public class DuoTai {
//同一个变量，同一个方法，能够执行出不同的结果
//如动物类，方法：移动。鱼是游，老鹰是飞
	public DuoTai() {
		// TODO Auto-generated constructor stub
	}
	public static void main(String[] args) {
		Animal jack = new Fish();
		jack.move();
		Animal rose = new Hawk();
		rose.move();
	}
}

class Animal{//抽象类
	void move(){//抽象方法
		
	}
}

class Hawk extends Animal{
	void move() {
		System.out.println("飞行");
	}
}

class Fish extends Animal{
	void move(){
		System.out.println("游泳");
	}
}

10.6.abstract、interface

public class Abstract {
/*使用abstract关键字定义的类叫做抽象类，用这个关键字定义的方法称为抽象方法
 * 抽象方法没有方法体，方法本身无意义，除非被重写，承载这个抽象方法的抽象类必须被继承。
 * 抽象类除了被继承之外毫无意义，其存在的意义在于其设计性、复用性与扩展性。
 * 1.是不完整的，可以理解为类中的方法并没有完全实现
 * 仅是对功能和属性的声明，表示这类事物应该具备这些内容。
 *2. 一般将父类定义为抽象类，需要用这个父类进行继承和多态处理。
 *抽象类被继承后需要实现其中所有的抽象方法
 * 3.限制程序员不能直接创建该抽象类对象，必须定义其子类才可使用。
 * 继承抽象类的所有子类需要将抽象类中的抽象方法进行覆盖。
 */
	/*接口是抽象类的延伸，接口中的所有方法都没有方法体
	 * 抽象类有复用性，抽象类被继承后需要实现其中所有的抽象方法（冗余）有的抽象方法不需要被继承，
	 * 于是就有了接口，将方法封装到接口中，需要这个方法的可以先继承父类，然后再用这个接口
	 * 接口中，方法被定义为public和abstract形式，在接口中的任何字段都自动是static和final
	 */
	public Abstract() {
		// TODO Auto-generated constructor stub
	}
	public static void main(String[] args) {
		AlarmDoor a = new AlarmDoor();//java不允许多重继承，但使用接口可以实现，一个类可以有多个接口。
		a.alarm();
		//Door b = new Door();抽象类不能被实例化
		//System.out.println(a.alarm());不能输出无参函数
	}
	
}
//alarm()门铃报警属于延伸的附加行为。
	interface Alram {
		public  void alarm();
	}
	 //open()和close()属于门本身固有的行为特性
	abstract class Door {
		public abstract void open();
		public abstract void close();
	}
	 
	class AlarmDoor extends Door implements Alram {
		public  void open() {
	      System.out.println("门是开的");
	    }
		public  void close() {//子类不能用静态方法 重写 父类的非静态方法
			System.out.println("门是关的");
	    }
		public  void alarm() {
			System.out.println("门是有警报的");
	    }
	}

11.1类名冲突、final

public class LeiMingCHongTu {
	public LeiMingCHongTu(){
		
	}
//1.当类名发生冲突时，要把相同的类名放到不同的包中
//自己创建的类会覆盖掉API中的类
/*2.完整类名=包名.类名
 * java.util.Date date1 = new java.util.Date();
 * 在API中的类不写完整类名需要导入才能分辨。
 */
/*3.类包：相当于一个容器，将类放入其中归纳整理
 * 当需要其中的类时，可以通过调用实现
 * import java.util.Date；导入类包后不用写完整类名，必须写在最上面
 * import java.util.*；一次性将包中的类全部导入
 * 若想调用两个包内的相同类，一个导入类，另一个将包全部导入，然后用完整类名
 * 同包下可不用调用直接就可用
 * 4.变量经过final修饰会变成一个常量，不允许更改
 * final修饰类是不允许被继承，修饰方法时不允许被重改，被写死
 * 写法：放在class前
 * 如String类，是一个final类，不允许被继承
 * 
 */
	public static void main(String[] args) {
		System.out.println("nihao");//其中蓝色的out是静态成员，可以导入
		//out.println();//ctrl+shift+o会帮助导入没有被导入的包
	} 
  
}

11.2成员内部类

public class NeiBuLei {
//5.内部类：类的内部还有类，在类体里面定义了新类
// 分为：成员内部类，局部内部类，静态内部类，匿名内部类
	public NeiBuLei() {
		// TODO Auto-generated constructor stub
	}
	innerclass in = new innerclass();
	public void outf() {
		in.inf();
	}

	class innerclass{
		int y = 0;
		public innerclass() {
			
		}
		public void inf() {
			System.out.println("内部类方法y="+y);
		}
	}
    
    class NewClass extends NeiBuLei.innerclass{
		public NewClass(NeiBuLei d) {//必须是有参构造函数
			d.super();//这种写法是强制的
		}
	}
	public static void main(String[] args) {
		NeiBuLei d = new NeiBuLei();
		d.outf();//外部类方法调用内部类方法
		NeiBuLei.innerclass in = d.in;//或者d.new innerclass(),创建内部类成员
		in.inf();
	}
}

11.3局部内部类

public class JuBuNeiBuLei {

	public JuBuNeiBuLei() {
		// TODO Auto-generated constructor stub
	}
	public outInterface action (String x) {//方法体之外不存在这个类，不能返回
		class innerclass2 implements outInterface{
			public innerclass2(String s) {
				s=x;
				System.out.println(s);
			}
		}
		return new innerclass2("do");
	}
	public static void main(String[] args) {
		JuBuNeiBuLei d = new JuBuNeiBuLei();
		d.action("局部内部类");
	}

}
interface outInterface{
	
}

11.4匿名内部类

public class NiMingNeiBuLei {

	public NiMingNeiBuLei() {
		// TODO Auto-generated constructor stub
	}
	public outInterface2 action() {
		//return new innerclass2();
		return new outInterface2() {//没有名字的内部类，使用时才进行编写
			private int i = 0;
			public int getValue() {
				return i;
			}
		}
	}
}
interface outInterface2{
	
}
//class innerclass2 implements outInterface{
//	private int i = 0;
//	public int getValue() {
//		return i;
//	}
//}

11.5静态内部类

public class JingTaiNeiBuLei {

	public JingTaiNeiBuLei() {
		// TODO Auto-generated constructor stub
	}
	static int x=100;//只有x是静态的才能被静态内部类调用
	static class innerclass4{//静态内部类可以调用main方法，给提供一个调试的功能
		public static void main(String[] args) {
			System.out.println("我是静态内部类");
		}
	}
}

12.1异常

public class Exception {
//程序运行中可能出现的错误，中断了程序执行中的正常指令流：异常——Throwable超类
	//exception,程序本身可以处理的错误---runtimeException运行期间抛出的异常
	//error,需要重写或者重新分配系统资源的错误，如字节码文件无法解析，虚拟机资源耗尽，配置文件格式不规范
	public Exception() {
		// TODO Auto-generated constructor stub
	}
	public static void main(String[] args) {
		//int a = 1/0;
		//System.out.println(a);
		//运行时出现：Exception in thread "main" java.lang.ArithmeticException:
		
		try {//捕捉异常
			int a = 1/0;
			System.out.println(a);//当异常发生时，后面的代码就不会运行了，异常的中断机制
		}catch(ArithmeticException e){//常见的五种异常
			System.out.println("发生了算术异常，请管理员及时处理！");
		}
		catch(NullPointerException e){
			System.out.println("发生了空指针异常，请管理员及时处理！");
		}//static Object o;没有加new Object；
		//o.方法（）；	出现空指针异常	
		catch(ClassCastException e){
			System.out.println("发生了类转换异常，请管理员及时处理！");
		}
		catch(ArrayIndexOutOfBoundsException e){
			System.out.println("发生了数组下标越界异常，请管理员及时处理！");
		}
		//Unreachable catch block for SQLException. 
		//This exception is never thrown from the try statement body
		//catch(ClassNotFoundException e){
		//	System.out.println("发生了未找到相应类异常，请管理员及时处理！");
		//}class.forName（java.lang.String）,若没有String就会出现此异常
		//catch(SQLException e){
		//	System.out.println("发生了操作数据库异常，请管理员及时处理！");
		//}
		//catch(IOException e){
		//	System.out.println("发生了输入输出异常，请管理员及时处理！");
		//}
		//catch(FileNotFoundException e){
		//	System.out.println("发生了文件未找到异常，请管理员及时处理！");
		//}
		//catch(IllegalAccessException e){
		//	System.out.println("发生了不允许访问异常，请管理员及时处理！");
		//}
		//循环内部异常
		for(int i = 0;i<5;i++) {
			try {//shift+alt+z 异常快捷键
				System.out.println("输出"+i+"行");
				int a = 1/i;
			} catch (java.lang.Exception e) {//异常类型 e
				// TODO Auto-generated catch block
				e.printStackTrace();//在命令行打印异常信息在程序中出错的位置及原因。
			}
		}
		//finally代码块,用来关闭操作
		/*有四种情况不会执行
		 * 1.finally块中发生异常
		 * 2.在前面的代码中运行了System.exit();强制中断程序
		 * 3.程序所在线程死亡，如需要输入值，一直没有输入
		 * 4.关闭cpu，类似于停电
		 */
		try {
			System.out.println("打开链接");
			int a =1/0;
			System.out.println("读取数据");
			
		} catch (java.lang.Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			System.out.println("关闭链接");
		}
	}
}

12.2自定义异常

import javax.swing.JOptionPane;

public class CustomException extends java.lang.Exception{
	String message;
	public CustomException(String message) {
		super(message);
		this.message = message;
	}
	@Override
	public void printStackTrace() {
		// TODO Auto-generated method stub
		super.printStackTrace();
		//重写，生成对话框
		JOptionPane.showMessageDialog(null, message, "发生异常", JOptionPane.ERROR_MESSAGE);
	}
	
	public static void main(String[] args) {
		String playerType = "monkey";
		try {
			if(!playerType.equals("human")){
				throw new CustomException("有非人类选手"+playerType);
			}
			System.out.println("开始比赛！");
		}catch (java.lang.Exception e) {//异常类型 e
			// TODO Auto-generated catch block
			e.printStackTrace();//在命令行打印异常信息在程序中出错的位置及原因。
		}
	}
}

12.3抛出异常

public class ThrowException {
//throws将代码中可能产生的异常交给别人来处理。用在方法之后，被调用时，需要捕捉
	public static void show() throws InterruptedException , NullPointerException{
		for(int i=0;i<10;i++) {
			System.out.println(i);
			Thread.sleep(1000);//休眠一秒
		}
	}
	public static void main(String[] args) {
		try {//对抛出的异常进行处理
			show();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}catch (NullPointerException e) {
			e.printStackTrace();
		}
	}
	
}

12.4异常处理原则

import java.io.FileNotFoundException;

public class ExceptionYUANZE {

	//当遇到异常时，需要查找api进行抛出或者捕捉处理
	/*
	 * 1.不要老是抛出异常
	 * 2.不要忽略捕捉到的异常,在catch时要积极处理
	 * 3.不要过度的使用异常，如try很少，catch很多
	 * 4.不要使用过于庞大的try-catch块，错误多甚至找不到
	 * 5.子类抛出的异常不能比父类更高级,子类抛出的异常必须包含在父类抛出的异常之内，
	 * runtimeexception（运行时异常）异常及其子类不受此原则约束，子类抛出比父类高级不会报错
	 */
	public class Parent{
		public void action() throws FileNotFoundException {
			
		}

	}	
	class Child extends Parent{
		public void action() throws FileNotFoundException {//Exception就会报错
			//an exception type must be a subclass of Throwable
		}
	}
}

13.1集合

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Set {
//集合类就像是一个容器，相当于一个动态数组,
//Map(HashMap,TreeMap)，Set(HashSet,TreeSet)，List(ArrayList,LinkList)三个接口隶属于java.util包
//Set，List隶属于Collection接口，有add();remove();isEmoty();size();iterator()等方法
	
	public static void main(String[] args) {
		Collection c = new ArrayList();
		System.out.println("集合时候为空"+c.isEmpty()+"集合长度"+c.size());
		c.add("你好！");
		c.add(3.14);
		c.add(new Object());//Object对象，后面是hash码
		System.out.println("集合时候为空"+c.isEmpty()+"集合长度"+c.size());
		Iterator it = c.iterator();//迭代器可以遍历集合元素，并将他们取出来
		while (it.hasNext()) {
			Object o = it.next();
			System.out.println(o);
		}
		c.remove(3.14);
		System.out.println("集合时候为空"+c.isEmpty()+"集合长度"+c.size());
	}
}

13.2List（列表）

import java.util.ArrayList;
public class List {
//List集合，有两个实现类，分别是ArrayList,LinkedList
//ArrayList更善于查找,LinkList更善于添加和删除，数据结构决定的
//语法 List list = new ArrayList();
//     List list = new LinkList();
//方法 add()添加;get()获取;remove()删除;set()更改;
	public static void main(String[] args) {
		ArrayList list = new ArrayList();//同LinkedList相同
		list.add("清明时节雨纷纷");
		list.add("孤家寡人欲断魂");
		list.add("借问美女何处有");
		list.add("牧童遥指三里屯");
		System.out.println(list.get(0));
		list.add(1, "我插一句");
		list.set(2, "我改一句");
		list.remove(0);//索引会往前挪
		list.add("牧童遥指三里屯");
		list.add("牧童遥指三里屯");//体现出动态数组
		
		for(int i=0;i<list.size();i++) {
			System.out.println("list索引为"+i+"的元素为："+list.get(i));
		}
	}
}

13.3.TreeSet （树集）

import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

import SetClass_13.Set_.Person;

public  class Set_ {
//Set接口有两个实现类，分别是HashSet,TreeSet,元素不重复
//语法 Set set = new TreeSet();树状集合，存放有序
//     Set set = new HashSet();散列集合，高效快速
//方法 添加add();删除remove();检查元素是否存在contains(Object o);迭代器iterrator();
	public  static class Person implements Comparable{//静态类才能被调用
		int id;
		int age;
		String name;
		
		public Person(int id, int age, String name) {
			super();
			this.id = id;
			this.age = age;
			this.name = name;
		}

		@Override
		public String toString() {
		return "person [id=" + id + ", age=" + age + ", name=" + name + "]";
		}
		@Override
		//要想实现集合的存放顺序，被排序的对象应该实compareTo现接口
		public int compareTo(Object o) {
			Person p;
			if(o instanceof Person) {
				p = (Person)o;
			}else {
				return -1;//-1代表传入的参数比我本身要小
			}
			int diff = this.id -p.id;//若是比较年龄可换成age
			if(diff!=0) {
				diff = diff / Math.abs(diff);//结果不是1就是-1
			}
			return diff;
		}
		

	}
	public static void main(String[] args) {
		Set set = new TreeSet();//两个类都要导入，否则报错
		Person p1 = new Person(1,18,"小明");
		Person p2 = new Person(2,5,"小红");
		Person p3 = new Person(3,20,"小花");
		set.add(p1);
		set.add(p1);
		set.add(p2);
		set.add(p3);
		System.out.println(set.size());
		Iterator it = set.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		
	}
	
}

13.4HashSet（哈希）

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;


//hashset存储的对象，应该重写hashcode和equals两个方法。
public class HASHset {

	public static class Person{
		int id;
		String name;
		public Person(int id, String name) {
			super();
			this.id = id;
			this.name = name;
		}
		@Override
		public String toString() {
			return "Person [id=" + id + ", name=" + name + "]";
		}
		@Override
		public int hashCode() {
			final int prime = 31;
			int result = 1;
			result = prime * result + id;
			return result;
		}
		@Override
		public boolean equals(Object obj) {
			if (this == obj)
				return true;
			if (obj == null)
				return false;
			if (getClass() != obj.getClass())
				return false;
			Person other = (Person) obj;
			if (id != other.id)
				return false;
			return true;
		}
			
	}
	public static void main(String[] args) {
		Set set = new HashSet();
		Person p1 = new Person(1,"小明");//1
		Person p2 = new Person(2,"小红");//2
		Person p3 = new Person(3,"小花");//3
		Person p4 = new Person(3,"阿强");//3
		set.add(p1);
		set.add(p2);
		set.add(p3);
		set.add(p4);
		System.out.println(set.size());
		/*
		 * 当新元素要插入集合中时，会先被要到hash值，如果值里面没有元素，会被插入到集合中
		 * 若相同地址里面有元素，会被调用equals方法，然后比较(比较的是id)，若是相同对象，就不会进入到集合中
		 * 如果比较是不同，那么会在同一个hash值下有多个元素
		 * 只要地址和hash值有一个不同就可以
		 */
		p2.id = 5;
		//set.remove(p2);//移除的是为2的id，不要乱改hash值
		set.add(p2);//会导致地址不同，
		
		Iterator it = set.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
			
		}
	}
		
	
}

13.5MAP（字典）

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
//相当于字典，通过键值对来进行映射
//形式为Map<K, V>;
//方法有get取得值，put创造，containsKey是否包含键，containsValue；
//实现类，HashMap散列码键值对，速度更快；TreeMap树状键值对，存放有序
public class MAP {
	public static void main(String[] args) {
		Map map = new HashMap();
		map.put(1,"1");	
		map.put("nihao", 123);
		map.put(new Object(), new Object());
		
		System.out.println(map.size());
		
		Set set = map.keySet();//输出键值
		Iterator it = set.iterator();
		while(it.hasNext()) {
			Object obj = it.next();
			System.out.println("键="+obj+"   值="+map.get(obj));
			System.out.println(map.get(2));
			System.out.println(map.containsKey(5));
		}
		
	}

	

}

weixin_42675851

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
java进阶

目录10.1继承10.2.Object10.3ClassCast10.4.MethodOverload10.5.DuoTai10.6.abstract、interface11.1类名冲突、final11.2成员内部类11.3局部内部类11.4匿名内部类11.5静态内部类12.1异常12.2自定义异常12.3抛出异常12.4异常处理原则13.1集合13.2List（列表）13.3.TreeSet（树集）13.4HashSet（..
复制链接

扫一扫