java 四大特性

最新推荐文章于 2024-04-21 13:05:08 发布

console_log_LGA

最新推荐文章于 2024-04-21 13:05:08 发布

阅读量424

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/console_log_LGA/article/details/99694285

版权

java 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

一.类和对象:
类:是一类事物特征抽象的集合,表示一个共性的产物, 类中包括属性(静态属性) 和方法(动态属性) 注: 类中属性和方法也可以没有!!!

对象 :是类的实例, 是抽象的具体化,

类定义完成后不能直接使用, 如果要使用,必须在(main)主方法中创建对象…由于类属于引用数据类型, 所以对象的产生格式如下:
语法: 声明并实例化对象
类名称对象名称 = new 类名称();
当一个实例化对象产生之后，可以按照如下的方式进行类的操作：
对象.属性：表示调用类之中的属性；
对象.方法()：表示调用类之中的方法。

==========================================================================================================================
二, 封装
概念: 隐藏对象的属性和细节,仅对外提供公共的方法进行访问
a).当类的成员变量使用private 修饰符修饰, 就不可以直接访问到该成员变量
b). 当使用private修饰的成员变量或者成员方法,仅能在本类中使用
c).private 对于main方法的修饰,也可以产生作用.

语法:
private 数据类型变量名;
设置get和set方法;
set设置属性, get获取属性值

三,继承
1.关键字：extends
2.语法：

  修饰符  子类  extends  父类{

   // 类定义部分           

  }

在java中只支持单继承，即每个类只能有一个直接父类；定义一个类时，
如果没有使用extends关键字那么这个类直接继承Object类，Object类是所有java类的祖先。
super 关键字:
super 表示使用它的类的父类。super 可用于：

调用父类的构造方法（带参）；
调用父类的方法（子类覆盖了父类的方法时，即重写）；
访问父类的数据域（可以这样用但没有必要这样用）。

方法重写（方法的覆盖）

(Override)
1.定义：在子类中可以根据需求对从父类继承的方法进行重新编写，称为方法的重写或方法的覆盖。

a.重写方法和被重写方法必须具有相同的方法名 , 相同的参数列表

, 返回值类型相同

重载(Overload)
重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。
每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。

抽象类:
关键字abstract
抽象类和抽象方法特点：

(1)抽象类和抽象方法都通过abstract?关键字来修饰。

(2)抽象类不能实例化。抽象类中可以没有、有一个或多个抽象方法，甚至全部方法都可以是抽象方法。

(3)抽象方法只有方法声明，没有方法实现。有抽象方法的类必须声明为抽象类。子类必须重写所有的抽象方法才能实例化，否则子类还是一个抽象类。

(4) 抽象类可以没有抽象方法，有抽象方法的类必须是抽象类。

四,多态:
多态的三个必要条件：
1、要有继承（实现implements）
2、要有重写（overWrite&overRide)
3、父类引用指向子类对像
例：Object cat = new Cat(); (向上转型)
向下转型 : 当向上转型发生后, 将无法调用子类特有的方法. 但是当需要调用子类特有的方法时 , 可以通过将父类再转换为子类来实现
语法:
Father f = new Son（）；
Son s = （Son）f；

Java中提供了instanceof运算符来进行类型的判断:

public void play(Pet pet){

if(pet instanceof Dog){ //判断pet这个类是不是Dog这个类型的

Dog dog=(Dog)pet;//向下转换

dog.shakeHands();

}
else if(pet instanceof Penguin){

                   Penguin penguin=(Penguin)pet;

penguin.swim();

else if(pet instanceof Cat){

Cat cat=(Cat)pet;
cat.climb();
}
}
}

实现多态的两种形式:
　　a.使用父类作为方法形参实现多态
　　public void feed(Pet pet){ p.eat; }
if (feiend instanceof American) {
American american = (American) feiend;
american.eat(“美国菜”);
american.rugby();

 b.使用父类作为方法返回值实现多态
  　           //　public Pet getPet(int type){}

Master类

public class Master {
//多态形式3：父类作为方法返回类型，子类实例化? 类型自动转换

public Pet getPet(int typeId){

Pet pet=null;

if(typeId==1){

pet=new Dog();

}
else if(typeId==2){

                  pet=new Penguin();

               }

else if(typeId==3){

                   pet=new Cat();

}

                return pet;

}

===============================================================================================================================

五,接口:
1.接口概念:
*接口可以理解为一种特殊的类,由全局常量和公共的抽象方法所组成
*类是一种具体的实现体,而接口定义了某一批类所需要遵守的规范,
接口不关心这些类的内部数据,也不关心里面的方法实现细节,
它值规定这些类里必须提供某些方法.
2.接口定义:
*和类定义不同,定义接口不在使用class关键字,而是使用interface关键字

语法: public interface 接口名 extends 父接口1, 父接口2
{
零到多个常量定义…
int SUM=10;
零到多个抽象方法定义…
public abstract int calRent(int days);
}
接口就是用来被继承丶被实现的丶修饰符一般建议用public
注意: 不能使用private 和 protected修饰接口

*常量:
接口中的属性是常量,即使定义时不添加public static final 修饰符
系统也会自动加上
*方法:
接口中的方法是抽象方法,总是使用丶即使定义时不添加public abstract 修饰符
系统也会自动加上

3.使用接口:
*一个类可以实现一个或多个接口,实现接口使用implements关键字.
*java中一个类只能继承一个父类,是不够灵活的.通过实现多个接口可以做补充
列: 继承父类实现接口的语法为:
[修饰符] class 类名 extends 父类 implements 接口1,接口2
{
类体部分//如果继承了抽象类,需要实现继承的抽象方法;要实现接口中的抽象方法;
}
!!!如果要继承父类,继承父类必须在实现接口之前!!!

*接口在使用过程中,还经常与匿名内部类配合使用
*匿名内部类就是没有名字的内部类, 多用于关注实现而不关注实现类的名称
语法格式1:
接口名 a=new 接口名(){
public void 方法名(){
system.out.println(“匿名内部类实现接口”);
}
}; 分号结束
a.方法名();

简单语法格式2: 直接new 接口名
new 接口名(){
public void 方法名(){
system.out.println(“匿名内部类实现接口”);
}
}.方法名();

==============================================================================================================================

六. 异常:
java中所有的异常类都是从Throwable继承来的。Error类是jvm内部出现资源耗尽等问题时报的异常，这类异常往往无法解决。
我们这里所讲述的异常都是Exception类中的。
异常可以分为运行时异常（RuntimeException）和已检查异常(IOException等)。
一般对异常进行简单的处理，有两种处理方式，捕获和抛出。

捕获异常：使得异常不被抛到方法之外，也不需要throws规范
try{
//可能发生异常的代码
}
catch(异常的类型声明){
//发生异常时执行的代码
}
finally{
//无论是否发生异常都会执行的代码
}

throws
抛出的是异常的类型，声明在方法体外，可能会发生异常。

throw
抛出的是异常的对象，存在在方法体内，执行一定会抛出异常。

public void sex(String sex)throws Exception{
if(“男”.equals(sex)||“女”.equals(sex)){
this.sex=sex;
}else{
throw new Exception(“性别必须是男或者女”);
}
}

log4j开源日志记录工具导入:
右击项目-选择source folder创建文件夹
-导入log4j.properties
-右击项目-选择 folder创建文件夹
-导入log4j.jar文件
-右击log4j.jar文件-选择Build Path - Add to Build Path
创建项目引入 private static Logger logger1 = Logger.getLogger(Test.class.getName());
导入包:import org.apache.log4j.Logger;
完成
日志信息分类

1.等级由低到高：debug<info<warn<Error<Fatal;

2.区别：

debug 级别最低，可以随意的使用于任何觉得有利于在调试时更详细的了解系统运行状态的东东；

info 重要，输出信息：用来反馈系统的当前状态给最终用户的；

后三个，警告、错误、严重错误，这三者应该都在系统运行时检测到了一个不正常的状态。

warn, 可修复，系统可继续运行下去；

Error, 可修复性，但无法确定系统会正常的工作下去;

Fatal, 相当严重，可以肯定这种错误已经无法修复，并且如果系统继续运行下去的话后果严重。
异常描述
ArithmeticException 当出现异常的运算条件时，抛出此异常。例如，一个整数"除以零"时，抛出此类的一个实例。
InputMismatchException 欲得到的数据类型与实际输入的类型不匹配
ArrayIndexOutOfBoundsException 用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小，则该索引为非法索引。
ArrayStoreException 试图将错误类型的对象存储到一个对象数组时抛出的异常。
ClassCastException 当试图将对象强制转换为不是实例的子类时，抛出该异常。
IllegalArgumentException 抛出的异常表明向方法传递了一个不合法或不正确的参数。
IllegalMonitorStateException 抛出的异常表明某一线程已经试图等待对象的监视器，或者试图通知其他正在等待对象的监视器而本身没有指定监视器的线程。
IllegalStateException 在非法或不适当的时间调用方法时产生的信号。换句话说，即 Java 环境或 Java 应用程序没有处于请求操作所要求的适当状态下。
IllegalThreadStateException 线程没有处于请求操作所要求的适当状态时抛出的异常。
IndexOutOfBoundsException 指示某排序索引（例如对数组、字符串或向量的排序）超出范围时抛出。
NegativeArraySizeException 如果应用程序试图创建大小为负的数组，则抛出该异常。
NullPointerException 当应用程序试图在需要对象的地方使用 null 时，抛出该异常
NumberFormatException 当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常。
SecurityException 由安全管理器抛出的异常，指示存在安全侵犯。
StringIndexOutOfBoundsException 此异常由 String 方法抛出，指示索引或者为负，或者超出字符串的大小。
UnsupportedOperationException 当不支持请求的操作时，抛出该异常。
下面的表中列出了 Java 定义在 java.lang 包中的检查性异常类。

异常描述
ClassNotFoundException 应用程序试图加载类时，找不到相应的类，抛出该异常。
CloneNotSupportedException 当调用 Object 类中的 clone 方法克隆对象，但该对象的类无法实现 Cloneable 接口时，抛出该异常。
IllegalAccessException 拒绝访问一个类的时候，抛出该异常。
InstantiationException 当试图使用 Class 类中的 newInstance 方法创建一个类的实例，而指定的类对象因为是一个接口或是一个抽象类而无法实例化时，抛出该异常。
InterruptedException 一个线程被另一个线程中断，抛出该异常。
NoSuchFieldException 请求的变量不存在
NoSuchMethodException 请求的方法不存在

==============================================================================================================================

七, 集合
——ArrayList 　　线程不安全，查询速度快
——LinkedList　　链表结果，增删速度快

List（Collection子接口）
1.1 实例化
List list = new ArrayList();
***List是一个接口，不可直接实例化，通常情况下ArrayList实现类进行实例化。

1.2 增
1.2.1 add(obj)
***直接将obj对象加入List末位。

1.2.2 add(i, obj)
将obj对象加入第i位。

1.2.3 addAll©
Course[] course1 = {new Course(“3”,“离散数学”), new Course(“4”,“设计模式”)};
coursesToSelect.addAll(Arrays.asList(course1));
同时加入多个对象，需要注意的是，addAll方法的参数为collection对象，需通过Arrays类的asList方法将数组转换为collection对象才可。

1.2.4 addAll(i, c)
与1.2.3基本相同，将n个对象插入到第i位至第i+n位。

1.3 删
1.3.1 remove(obj)
Course cr = (Course) coursesToSelect.get(1);
coursesToSelect.remove(cr);
直接指定删除对象，若引用不同，删除失败。

1.3.2 remove(i)
删除List中第i位对象，较1.3.1中的方法更好。

1.4 改（set方法）
coursesToSelect.set(0, new Course(“5”,“计算机网络”));
第一个参数指定修改的位置，第二个是修改的内容，实质为新建一个修改后的对象插入到指定位置。

1.5 查
1.5.1 get(i)
获取List中第i位的对象。

1.5.2 通过迭代器遍历List
Iterator it = coursesToSelect.iterator();
while (it.hasNext()) {
Course cr = (Course) it.next();
}
1.5.3 通过for-each遍历
for (Object obj:coursesToSelect) {
Course cr = (Course) obj;
}
1.5.4 contains(obj)、containsAll©
System.out.println(“请输入要查询的课程名称：”);
String name = console.next();
Course course2 = new Course();
course2.setName(name);
System.out.println(“新建课程：” + course2.getName());
System.out.println(“备选课程中是否包含课程：” + course2.getName() + “，” + coursesToSelect.contains(course2));
contain方法的原理为：通过分别调用List中所有对象的equals方法与传递的参数进行比较，若有某一对象相等，则返回true，若无，则返回false。

需要注意的是，contains方法比较的并不是对象的值，而是对象的引用，若引用不同，即使值相等，返回值依然为false。

@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (!(obj instanceof Course)) {
return false;
}
Course course = (Course) obj;
if (this.getName() == null) {
if (course.getName() == null)
return true;
else
return false;
} else {
if (this.getName().equals(course.getName()))
return true;
else
return false;
}
}
如需通过值比较两对象是否相等，需重写List中存放的对象所属类中的equals方法。

1.5.5 indexOf(obj)、lastIndexOf(obj)
前者返回obj对象顺序第一次出现的索引位置，后者则为倒序遍历，若List中不存在该对象，则返回-1。

Set（Collection子接口）
2.1 实例化
Set courses = new HashSet();
通过HashSet实现类进行实例化。

2.2 增、删、改、查
了需要指定索引的方法外，其余与List基本一致。

需要注意的是，这里的Set是通过HashSet实现，因而其contains、containsAll方法除去equals方法外，还需逐个调用其hashCode方法，因此必须重写hashCode方法。

Map接口
3.1 实例化
Map<String, Student> students = new HashMap<String, Student>();
需指定key、value，即键值对的类型，通过HashMap实例化。

3.2 增
put(key, value)
3.3 删
remove(key)
3.4 改
Map中修改元素的方法为put，实质为通过新建一个key值重复的新的对象，覆盖需要修改的对象。

3.5 查
3.5.1 keySet()
public void testKeySet() {
//通过keySet方法，返回Map中的所有key的Set集合
Set keySet = students.keySet();
System.out.println(“总共有” + keySet.size() + “个学生”);
//遍历keySet，取得每一个key，再调用get方法取得每个key对应的value
for (String stuId : keySet) {
Student st = students.get(stuId);
if (st != null) {
System.out.println(“学生：” + st.getName());
}
}
}
新建Set用于承载keySet返回的集合时，需按照key的类型指定Set的类型。

3.5.2 entrySet()
public void testEntrySet() {
Set<Entry<String, Student>> entrySet = students.entrySet();
for (Entry<String, Student> entry : entrySet) {
System.out.println(“取得key：” + entry.getKey());
System.out.println(“取得value：” + entry.getValue().getName());
}
}
该函数返回的键值对的集合本身指定了泛型，因而新建Set集合时需要指定Entry的泛型。

3.5.3 values()（略）
3.5.4 containsKey(key)、containsValue(value)
判断Map中是否存在相应key值、value值的对象。

需要注意的是，同List、Set中的Contains方法一样，这两个方法的原理也是调用Map中所有元素的equals方法进行比较，因而需要重写equals方法。

Collections工具类

4.1 对Integer类型的List进行排序
List intList = new ArrayList();
//插入10个100以内的不重复随机数
Random random = new Random();
Integer k;
for (int i=0; i<10; i++) {
do {
k = random.nextInt(100);
} while (intList.contains(k));
intList.add(k);
}
System.out.println("-------排序前-------");
for(Integer i : intList) {
System.out.println(“元素：” + i);
}
Collections.sort(intList);
System.out.println("-------排序后-------");
for(Integer i : intList) {
System.out.println(“元素：” + i);
}
4.2 对String类型的List进行排序
List stringList = new ArrayList();
stringList.add(“microsoft”);
stringList.add(“google”);
stringList.add(“lenovo”);
System.out.println("-------排序前-------");
for(String s : stringList) {
System.out.println(“元素：” + s);
}
Collections.sort(stringList);
System.out.println("-------排序后-------");
for(String s : stringList) {
System.out.println(“元素：” + s);
}
从首个字符开始比较，若首字符相同，则比较第二个字符，以此类推。