java forest 获取variables参数

转载

mob64ca14144dde 2024-11-26 18:05:53

文章标签 网课笔记 System 子类父类 文章分类 Java 后端开发

1.extends：继承，子类继承父类非私有的属性

//父类
public class  Animal{
    public int foot;
	public int getFoot() {
		return foot;
	}
	public void setFoot(int foot) {
		this.foot = foot;
	}
	public void attck() {
		System.out.print("动物有"+foot+"脚");
	}
}
//子类
public class Cat extends Animal{

	public static void main(String[] args) {
		// TODO Auto-generated method stub
	}
}

public class ke {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
	Cat cat=new Cat();
	cat.setFoot(4);
	cat.attck();
	}
}
//结果显示动物有四只脚

2.函数的复写：子类继承了父类的方法，并重新改写了父类的函数

//父类
public class  Animal{
    public int foot;
	public int getFoot() {
		return foot;
	}
	public void setFoot(int foot) {
		this.foot = foot;
	}
	public void attck() {
		System.out.print("动物有"+foot+"脚");
	}
}
//子类
public class Cat extends Animal{
    @Override
	public void attck() {
		// TODO Auto-generated method stub
		//super.attck();
		System.out.print("如果有复写函数，就执行自身的复写函数，即使函数为空");
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
	}
}

public class ke {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
	Cat cat=new Cat();
	cat.setFoot(4);
	cat.attck();
	}
}
//结果显示如果有复写函数，就执行自身的复写函数，即使函数为空

3.super关键字：代表父亲

//父类
public class  Animal{
    public int foot;
	public int getFoot() {
		return foot;
	}
	public void setFoot(int foot) {
		this.foot = foot;
	}
	public void attck() {
		System.out.print("动物有"+foot+"脚");
	}
}
//子类
public class Cat extends Animal{
    @Override
	public void attck() {
		// TODO Auto-generated method stub
//先调用父亲的函数

		super.attck();
//
		System.out.print("如果有复写函数，就执行自身的复写函数，即使函数为空");
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
	}
}

public class ke {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
	Cat cat=new Cat();
	cat.setFoot(4);
	cat.attck();
	}
}
//结果显示动物有4脚如果有复写函数，就执行自身的复写函数，即使函数为空

4.object类是所有类的父类

5.java中类的继承是单一继承，一个子类只能拥有一个父类，所以extends只能继承一个类。

6.final关键字声明类可以把类定义为不能继承，即最终类；

或者用于修饰方法，该方法不能被子类重写；

实例的变量也不能被修改；

被声明final类的方法自动声明为final，但是实例变量并不是final。

7.声明一个类，如果要实现这个类，要实现它的构造函数。

8.使用abstract关键字声明的类被称为抽象类，需要扩展和实现它的方法，它不能被实例化。只能有它的子类去实现。

//抽象类
public abstract class Bonus {
	public String location;
	private int money;
	abstract void getMoney();
}
//继承抽象的子类
public class FIndBonus extends Bonus {
@Override
	void getMoney() {
		// TODO Auto-generated method stub
		System.out.print("aa");
	}
}
//用抽象类的子类是实例化
public class Text {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//Bonus抽象类不能被实例化，可以new它的子类：向下转型，java多态
		Bonus bonus=new FIndBonus();
		bonus.getMoney();
	}
}

9.异常

//抛出异常
public class ZooKeeper {
	public void feedAnimal(int foodAmount) throws MyException {
		switch (foodAmount) {
		case 100:
			System.out.print("100");
			break;
		case 200:
			throw new MyException();
		default:
			break;
		}
	}
}
//自定义异常
public class MyException extends Exception {
	public String getMessage() {
		return "this is my exception";
	}
}
//测试异常
public class Test {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ZooKeeper zooKeeper = new ZooKeeper();
		try {
			zooKeeper.feedAnimal(200);
		} catch (MyException e) {
			// TODO Auto-generated catch block
			System.out.print(e.getMessage());
		}
	}
}

10.IO的使用

public static void main(String[] args) {
		// TODO Auto-generated method stub
		File txtFile = new File("/Users/shawn/Desktop/", "1.txt");
		OutputStream outputStream = null;
		try {
			outputStream = new FileOutputStream(txtFile);
			String content = "good good study";
			outputStream.write(content.getBytes());
		} catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}finally {
			try {
				outputStream.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		InputStream inputStream = null;
		try {
			inputStream = new FileInputStream(txtFile);
			// 读完之后放到缓冲区里
			byte[] readBytes = new byte[1024];
			inputStream.read(readBytes);
			System.out.print(new String(readBytes));
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			try {
				inputStream.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}

	}

11.访问权限：

private：被修饰的类、属性以及方法只能被该类的对象访问，其子类不能访问，更不能允许跨包访问。

default：即不加任何修饰符，只允许同一个包进行访问。

protect：介于public和private之间。被其修饰的类、属性以及方法只能被类本身的方法及子类访问，即使子类在不同的地方的包也可以访问。

public：被其修饰的类、属性以及方法不仅可以跨类访问，而且允许跨包访问。

	同一个类	同一个包	不同包的子类	不同包的非子类
private	√
Default	√	√
protect	√	√	√
public	√	√	√	√

12.接口的声明：1.修饰符 2.关键字：interface 3.抽象函数（可有可无）

//接口，具体实现声明功能不管
public interface USBinterface {
	//抽象函数，接口的函数不能实例化
	void charge() ;
}
//具体实现的功能
public class USBKeyboard implements USBinterface{
	@Override
	public void charge() {
		// TODO Auto-generated method stub
		System.out.print("I am USBkeyboard");
	}
}
//打印
public class Test {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//接口不能被实例化，所以只能实现它的子类；java多态
		USBinterface usb=new USBKeyboard();
		usb.charge();
	}
}

13.接口与抽象类的区别：

（1：抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口的方法不行。

（2：抽象类的成员变量可以是各种类型，接口的成员变量只能是public static final类型的。

（3: 接口中不能含有静态代码块以及静态方法（用static修饰的方法，只要类的实例才有static），而抽象是可以有静态代码块和静态方法的。

（4: 一个类只能继承一个抽象类，却可以实现多个接口（单继承，多实现）。

14.接口的常规用法：

public interface USBinterface {
	//抽象函数，接口的函数不能实例化
	void charge() ;
}

public interface WifiInterface {
	void getWifiStrength();
}

public class USBKeyboard implements USBinterface,WifiInterface{
	@Override
	public void charge() {
		// TODO Auto-generated method stub
		System.out.print("I am USBkeyboard");
	}
	@Override
	public void getWifiStrength() {
		// TODO Auto-generated method stub
		System.out.print("wifi is good");
	}
}

public class Test {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//接口不能被实例化，所以只能实现它的子类；java多态
		//这此创建的对象是USBKeyboard的，上一次是USBinterface；不是多态
		USBKeyboard usb=new USBKeyboard();
		usb.charge();
		usb.getWifiStrength();
	}
}

15.interface的特殊用法：用来放置常量

//设置参数存放数据
public interface SettingParams {
	public static final int TYPE_WIFI=0;
	public static final int TYPE_CELL=1;
	public static final int TYPE_4G=1;
}

public static void main(String[] args) {
		// TODO Auto-generated method stub
		if(SettingParams.TYPE_WIFI==0) {
			System.out.print("wifi connect");
		}
	}

16.接口命名规范：如果IBus；IAnimal；IUsb

17.接口可以被继承

//父类
public interface IHouse {
	void living();
}
//继承的子类
public interface IFilmHouse extends IHouse {
	void watchFilm();
}
//接口实现
public class MyHouse implements IFilmHouse{
	@Override
	public void living() {
		// TODO Auto-generated method stub
		System.out.print("my house can living");
	}
	@Override
	public void watchFilm() {
		// TODO Auto-generated method stub
		System.out.print("I can watch film");
	}

}
//测试
public class Test {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		IFilmHouse house=new MyHouse();
		house.living();
		house.watchFilm();
	}

18.数组：长度固定

public static void main(String[] args) {
		// TODO Auto-generated method stub
		//如何定义数组;两种写法
		int[] array;//推荐
		int array1[];
		//定义并且赋值；三种写法
		int[] array3=new int[] {1,2,3};
		
		int[] array4= {1,2,3};//直接赋值,推荐
		
		int[] array5=new int[3];//指定长度
		array5[0]=5;
		array5[1]=2;
		array5[2]=3;
	
		//数组的长度
		System.out.print(array5.length);
		//数组当中某个位置元素的值
		System.out.print(array5[1]);//打印数组array5第二个的值
		
		//排序(从小到大）
		Arrays.sort(array5);
		for(int i=0;i<array5.length;i++) {
			System.out.print(array5[i]);
		}
		
	}

19.集合，长度不定

public static void main(String[] args) {
		// TODO Auto-generated method stub
		//利用Arrays工具类生成集合
		Arrays.asList("Lily","Lucy","HanMei");
		//自己手动陈生成集合
		List<String> list=new ArrayList<String>();
		list.add("aaa");
		list.add("bbb");
		list.add("ccc");
		//迭代器打印
		Iterator<String> iterator=list.iterator();
		while (iterator.hasNext()) {
			//String string = (String) iterator.next();
			System.out.print(iterator.next());		
		}
		//如果不需要用到索引，可以用增强型for循环（foreach打印
		for(String str:list) {
			System.out.print(str);
		}	
        //洗牌，打乱顺序shuffle
		Collections.shuffle(list);
		for(String str:list) {
			System.out.print(str);
		}	
	}

20.ArrayList和LinkedList:

(1: ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。

(2: 对于随机访问get和set，ArrayList优于LinkedList，因为LinkedList要移动指针。

(3: 对于新增和删除操作add和remove，LinkedList优于ArrayList，因为ArrayList要移动数据。

21.集合的分类：（1）Collection接口（2） Map接口

22.HashMap、LinkedHashMap和TreeMap的区别：

（1: HashMap是一个最常用的Map，它根据键的HashCode值存储数据，根据键可以直接获取它的值，具有很快的访问速度。遍历时，取得数据的顺序是随机的。

（2：HashMap最多只允许一条记录的键为Null；允许多条记录的值为null。

（3:HashMap不支持线程的同步（即任一时刻可以有多个线程同时写HashMap),可能会导致数据的不一致，如果需要同步们可以用Collections的synchronizedMap方法是HashMap具有同步的能力，或者使用ConcurrentHashMap。

（4: Hashtable和HashMap类似，它继承自Dictionary类。不同的是：它不允许记录的键或者值为空；它支持线程的同步（即任一时刻只有一个线程能写Hashtable），因此也导致了Hashtable在写入是会比较慢。

（5:LinkedHashMap保存了记录的插入顺序，在用iterator遍历LinkedHashMap时，先得到的记录肯定是先插入的。也可以在构造时带参数，按照应用次数排序。

（6:TreeMap实现SortMap接口，能够把它保存的记录根据键排序。

（7:默认是按键值的升序排序，也可以指定排序的比较器，当用iterator遍历TreeMap时，得到的记录是排序过的。

三种类型分别在什么时候使用：

（1:一般情况下，最多使用的是HashMap。HashMap里存入的键值对在取出的时候是随机的，在Map中插入、删除和定位元素，HashMap是最好的选择。

（2:TreeMap去取出来的是排序后的键值对，但如果按自然顺序或自定义顺序遍历键，那么TreeMap会更好。

（3:LinkedHashMap是HashMap的一个子类，如果需要输出的顺序和输入相同，那么用LinkedHashMap可以实现，它还可以按读取顺序来排列，想连接池中可以应用。

23.包装类

public static void main(String[] args) {
		// TODO Auto-generated method stub
		int num=10;
		//基本数据类型转换为包装类
		//利用API转换成了包装类
		@SuppressWarnings("deprecation")
		Integer num2=new Integer(num);
		System.out.print(num2.intValue());
		//自动装箱
		Integer num3=num2;
		System.out.print(num3);
		
		//包装类转换为基本数据类型
		//利用函数API
		Integer num4=100;
		num4.intValue();
		//利用自动拆箱
		int num5=num4;
		System.out.print(num5);
		
		//基本数据类型转换为字符串
		//+：进行字符串的拼接
		System.out.print(5+"");
		
		//将字符串转换为数字
		int parseInt=Integer.parseInt("5");
		long parseLong=Long.parseLong("5");
	}

24.日期

public static void main(String[] args) {
		// TODO Auto-generated method stub
		Date date=new Date();
		System.out.print(date);
	}

25.日历

public static void main(String[] args) {
		// TODO Auto-generated method stub
		Calendar c=Calendar.getInstance();
		System.out.print(c.get(Calendar.YEAR));//年
		System.out.print(c.get(Calendar.MONTH)+1);//月
		System.out.print("现在是"+c.get(Calendar.YEAR)+"年"+(c.get(Calendar.MONTH)+1)+"月"+c.get(Calendar.DAY_OF_MONTH)+"日"+
		c.get(Calendar.HOUR_OF_DAY)+"时"+c.get(Calendar.MINUTE)+"分"+c.get(Calendar.SECOND)+"秒");
		final char[] week= {'日','一','二','三','四','五','六'};
		int week_num=c.get(Calendar.DAY_OF_WEEK)-1;
		System.out.print("今天是星期"+week[week_num]);
		
	}

26.日期格式转换

public class TestSimpleDateFormat {
	public static final String TYPE_FORMAT="yyyy-MM-dd HH:mm:ss";
	//日期转字符
	public static String fromDatetoString(Date date,String format) {
		SimpleDateFormat dateFormat=new SimpleDateFormat(format);
		return dateFormat.format(date);
	}
	//字符转日期
	public static Date fromStringtoDate(String date,String format) throws ParseException {
		SimpleDateFormat dateFormat=new SimpleDateFormat(format);
		return dateFormat.parse(date);
		
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.print(fromDatetoString(new Date(), TYPE_FORMAT));
		try {
			Date date=fromStringtoDate("2019-07-14 23:41:26", TYPE_FORMAT);
			System.out.print(date);
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

27.Math数学运算:最大值

public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.print(Math.max(5, 1));
	}

28.多线程

（1:一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

（2:多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。

（3: 进程：一个进程包括由操作系统分配的内存空间，包含一个或多个线程。一个线程不能独立的存在，它必须是进程的一部分。一个进程一直运行，直到所有的非守护线程都结束运行后才能结束。

优先级：

（1:每一个 Java 线程都有一个优先级，这样有助于操作系统确定线程的调度顺序。

（2:Java 线程的优先级是一个整数，其取值范围是 1 （Thread.MIN_PRIORITY ） - 10 （Thread.MAX_PRIORITY ）。

默认情况下，每一个线程都会分配一个优先级 NORM_PRIORITY（5）。

（3:具有较高优先级的线程对程序更重要，并且应该在低优先级的线程之前分配处理器资源。但是，线程优先级不能保证线程执行的顺序，而且非常依赖于平台。

29.线程的创建方法

public class ThreadA extends Thread {

	public ThreadA() {
		// TODO Auto-generated constructor stub
	}

	public ThreadA(Runnable target) {
		super(target);
		// TODO Auto-generated constructor stub
	}

	public ThreadA(String name) {
		super(name);
		// TODO Auto-generated constructor stub
	}

	public ThreadA(ThreadGroup group, Runnable target) {
		super(group, target);
		// TODO Auto-generated constructor stub
	}

	public ThreadA(ThreadGroup group, String name) {
		super(group, name);
		// TODO Auto-generated constructor stub
	}

	public ThreadA(Runnable target, String name) {
		super(target, name);
		// TODO Auto-generated constructor stub
	}

	public ThreadA(ThreadGroup group, Runnable target, String name) {
		super(group, target, name);
		// TODO Auto-generated constructor stub
	}

	public ThreadA(ThreadGroup group, Runnable target, String name, long stackSize) {
		super(group, target, name, stackSize);
		// TODO Auto-generated constructor stub
	}

	public ThreadA(ThreadGroup group, Runnable target, String name, long stackSize, boolean inheritThreadLocals) {
		super(group, target, name, stackSize, inheritThreadLocals);
		// TODO Auto-generated constructor stub
	}
	public void run() {
		super.run();
		for(int i=0;i<10;i++) {
			System.out.print("threadA---count is"+i+"\n");
		}
	}

}


public class RunableB implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int i=0;i<10;i++) {
			System.out.print("threadB---count is"+i+"\n");
		}
	}

}


public class TestThread {
	public static void main(String[] args) {
		// TODO Auto-generated method stu
		ThreadA threadA=new ThreadA();
		threadA.start();
		RunableB runableB=new RunableB();
		Thread thread=new Thread(runableB);
		thread.start();
	}
}

Thread.run():线程按顺序执行,不体现抢占资源；

Thread.start();使线程开始执行，调用run方法，体现抢占资源；

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。