java基础知识点
java基础知识点
1、java 的类部类如果加上了private 后，外部类就不能访问了。
2、如果没有写修饰符，默认就是public修饰；
#3、读取配置文件
文件类容信息：
# chrome
brower=chrome
ipadress=http://localhost:8000
#ipadress=http://139.9.39.5:5900
#读取配置文件对象
Properties properties = new Properties();
//读写配置文件里面的数据
properties.load(new FileInputStream("./webdriver/config.properties")); 配置文件地址；
String browerName = properties.getProperty("brower");
for example:
/**
* 在配置文件读取域名的方法；
*/
public String readIp() {
String string=null;
Properties properties=new Properties();
try {
properties.load(new FileInputStream("webdriver/config.properties"));
string = properties.getProperty("ipadress");
} catch (IOException e) {
e.printStackTrace();
}
return string;
}
常用的读取
System.getProperty("user.dir") #这个意思是表示获取当前文件所在的地址；
File.separator #表示是分割符号
for example:
String proPath = System.getProperty("user.dir") + File.separator + "config" + File.separator + "log4j.properties";
#4、单列模式
#注：newInstance实例化对象是只能调用无参构造方法，在A、B类中并没有构造方法，是因为每个创建的类都有一个默认的无参构造方法，如果你重写了一个带参构造方法，想要使用newInstance，则必须指定一个无参构造方法，否则会报初始化错误）
#//获取捕获的异常信息
StringWriter errormsg = new StringWriter()
PrintWriter pw = new PrintWriter(errormsg, true)
e.printStackTrace(pw)
errormsg.toString()
#static关键字的作用（修饰类、方法、变量、静态块）
1. static修饰的类只能为内部类，普通类无法用static关键字修饰。static修饰的内部类相当于一个普通的类，访问方式为（new 外部类名.内部类的方法() ）。
public class OuterClass {
public static class InnerClass{
InnerClass(){
System.out.println("============= 我是一个内部类'InnerClass' =============");
}
}
}
public class TestStaticClass {
public static void main(String[] args) {
// 不需要new一个InnerClass
new OuterClass.InnerClass();
}
}
#如果将一个类设置为abstract，则此类必须被继承使用。此类不可生成对象，必须被继承使用。
Abstract可以将子类的共性最大限度的抽取出来，放在父类中，以提高程序的简洁性。
Abstract虽然不能生成对象，但是可以声明，作为编译时类型，但不能作为运行时类型。
Final和abstract永远不会同时出现。
当abstract用于修饰方法时，此时该方法为抽象方法，此时方法不需要实现，实现留给子类覆盖，子类覆盖该方法之后方法才能够生效。
#2. 构造函数与普通函数的区别：
（1）. 一般函数是用于定义对象应该具备的功能。而构造函数定义的是，对象在调用功能之前，在建立时，应该具备的一些内容。也就是对象的初始化内容。
（2）. 构造函数是在对象建立时由 jvm 调用, 给对象初始化。一般函数是对象建立后，当对象调用该功能时才会执行。
（3）. 普通函数可以使用对象多次调用，构造函数就在创建对象时调用。
（4）. 构造函数的函数名要与类名一样，而普通的函数只要符合标识符的命名规则即可。
（5）. 构造函数没有返回值类型
#String.format() 格式化
errorMessage.put(name, String.format("输入值类型不对, 控件name:[%s], 输入参数:[%s]", name, object))
#抽象类和接口的区别
# 1.抽象类
用abstract修饰的类叫做抽象类。
在讲抽象类之前有必要强调一下abstract修饰符：
1.abstract修饰的类为抽象类，此类不能有对象，（无法对此类进行实例化，说白了就是不能new）；
2.abstract修饰的方法为抽象方法，此方法不能有方法体（就是什么内容不能有）；
关于抽象类的使用特点：
1.抽象类不能有对象，（不能用new此关键字来创建抽象类的对象）；
2.有抽象方法的类一定是抽象类，但是抽象类中不一定有抽象方法；
3.抽象类中的抽象方法必须在子类中被重写。
同学们可能会问到：抽象类不能被“new”，抽象方法必须重写，那么定义它们做什么嘞？
答：抽象类生来就注定它是要被继承的，如果没有任何一个类去继承它的话，那么也就失去了它的意义；抽象方法生来就是要被重写的，而且是必须重写。（只要继承了某个抽象类，就必须去重写此抽象类中含有的抽象方法）
public abstract class Animal {
public abstract void eat();
public abstract void sleep();
}
#2.接口
接口就是一个规范和抽象类比较相似。它只管做什么，不管怎么做。通俗的讲，借口就是某个事物对外提供的一些功能的声明，其定义和类比较相似，只不过是通过interface关键字来完成
其中重要的几个知识点：
1.接口中的所有属性默认为：public static final ****；
2.接口中的所有方法默认为：public abstract ****；
3.接口不再像类一样用关键字 extends去“继承”，而是用 implements 去“实现”，也就是说类和接口的关系叫做实现，（例如：A类实现了B接口，那么成为A为B接口的实现类。而类与类之间的继承的话，叫做A类继承了B类，其中B类即为A类的父类）。实现接口与类的继承比较相似
#抽象类和接口区别：
含有 abstract 修饰符 class 即为抽象类，抽象类不能创建实际对象，含有抽象方法的抽象类必须定义为 abstract class。
接口可以说成是一种特殊的抽象类，接口中的所有方法都必须是抽象的，接口中的方法定义默认为 public abstract 类型，接口中的成员产量类型默认为 public static final。
a. 抽象类可以有构造方法，接口中不能有构造方法。
b. 抽象类中可以有普通成员变量，接口中没有普通成员变量。
c. 抽象类中可以包含非抽象普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的方法。
d. 抽象类中的抽象方法的访问权限可以是 public、protected 和(默认类型，虽然 eclipse 不报错，但也不能用，默认类型子类不能继承)，接口中的抽象方法只能是 public 类型的，并且默认即为 public abstract 类型。
e. 抽象类中可以包含静态方法，在 JDK1.8 之前接口中不能不包含静态方法，JDK1.8 以后可以包含。
f. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问权限可以是任意的，但接口中定义的变量只能是 public static final 类型的，并且默认即为 public static final 类型。
g. 一个类可以实现多个接口，用逗号隔开，但只能继承一个抽象类，接口不可以实现接口，但可以继承接口，并且可以继承多个接口，用逗号隔开。
java 是单继承，多接口实现。
#final类有什么特点:
final类不能被继承，没有子类，final类中的方法默认是final的。
final方法不能被子类的方法覆盖，但可以被继承。
final成员变量表示常量，只能被赋值一次，赋值后值不再改变。
final不能用于修饰构造方法。
注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。
#final修饰的方法可以被重载 但不能被重写:
1.final修饰变量，则等同于常量,只能赋值一次。
2.final修饰方法中的参数，称为最终参数。for example :test(final By by)
3.final修饰类，则类不能被继承
4.final修饰方法，则方法不能被重写。
final 不能修饰抽象类
override overload
#日志类：
public class LoggerControler {
private static Logger logger = null;
private static LoggerControler loggCon = null;
public static LoggerControler getLogger(Class<?> T) {
if (logger == null) {
Properties props = new Properties(); //实例化一个Properties类，处理log4j.Properties文件
//File.separator 这样写的目的是避免不同的系统符号不相同。（适配在同步的系统使用）
System.out.println("获取当前文件所在的地址："+System.getProperty("user.dir"));
String proPath = System.getProperty("user.dir") + File.separator + "config" + File.separator + "log4j.properties";
InputStream inputStream = null;
try {
inputStream = new FileInputStream(proPath);
props.load(inputStream);
//log4j的PropertyConfigurator类的configure方法输入数据流
PropertyConfigurator.configure(props);
logger = Logger.getLogger(String.valueOf(T));
loggCon = new LoggerControler();
} catch (IOException e) {
e.printStackTrace();
}
}
return loggCon;
}
//重写logger方法
public void config(String msg) {
logger.config(msg);
}
public void info(String msg) {
logger.info(msg);
}
public void warning(String msg) {
logger.warning(msg);
}
public void severe(String msg) {
logger.severe(msg);
}
}
#charsequence
1 characterSet为字符编码 可以是iso-8859-1,utf-8等编码名称
2 charsequence为字符序列接口，即由字符构成的序列需要具备的功能
3 String类型是Charsequence接口的实现，自然，所有使用charsequence字符序列接口类型的程序，都可以使用其不同的实现，常见的是String 类型，所以调用时大部分情况下输入的都是字符串
单列模式
枚举：尽量只是用枚举的简单特性，定义枚举就是为了方便使用，枚举里面对象都是静态的常量。
学习Java
了解jmm jvm 原理
学习路径：
第一阶段
第二阶段
第三阶段
创建一个对象：
1. private 是完全私有的,只有当前类中的成员能访问到.
2.protected 是受保护的,只有当前类的成员与继承该类的类才能访问.
3.这两个是访问类中成员权限的限制符.在类外如果想使用类中的成员,只能直接使用public类型的,protected和private都是不能访问的,对于类外使用而言,这两个是完全相同的.
return作用
1.在方法里里面返回值。
2.结束方法运行，return；返回为空。
浙公网安备 33010602011771号