Static关键字
静态代码块：只执行一次。
Person.java
package com.mysoft.oop.demo08;
public class Person {
//2：赋初值
{
System.out.println("匿名代码块");
}
//1:只执行一次
static {
System.out.println("静态代码块");
}
//3
public Person() {
System.out.println("构造方法");
}
public static void main(String[] args) {
new Person();
System.out.println("==============");
new Person();
}
}
出力结果：
静态代码块
匿名代码块
构造方法
==============
匿名代码块
构造方法
静态导入包：
import static java.lang.Math.random;
Test.java
package com.mysoft.oop.demo08;
public class Test {
public static void main(String[] args) {
System.out.println(Math.random());
}
}
package com.mysoft.oop.demo08;
//静态导入包
import static java.lang.Math.random;
public class Test {
public static void main(String[] args) {
//System.out.println(Math.random());
System.out.println(random());
}
}
一个类如果被final修饰了，这个类就不能再被继承了。
抽象类
abstract修饰的类，就是抽象类；修饰的方法就是抽象方法。
抽象类不是重点！ 接口才是重点
//多继承~ 利用接口实现多继承~
//实现了接口的类，都需要重写接口中的方法~
约束
Action.java
package com.mysoft.oop.demo09;
//abstract 抽象类:类 extends 单继承~ (接口可以多继承 )
public abstract class Action {
//约束~有人帮我们实现
//abstract，抽象方法，只有方法名字，没有方法的实现！
public abstract void dosomething();
//1.不能new这个抽象类，只能靠子类去实现它; 约束!
//2.抽象类中可以写普通方法
//3.抽象方法必须在抽象类中
// 抽象的抽象：约束!
public void hello() {
System.out.println("hello");
}
//思考题？ new，存在构造器么？ (经过查看抽象类的class文件，抽象类也有构造方法）
//存在的意义？ 抽象出来 提高开发效率，节省代码。
}
A.java
package com.mysoft.oop.demo09;
//抽象类的所有方法，继承了它的子类，都必须要实现它的方法！除非~
public class A extends Action {
@Override
public void dosomething() {
System.out.println("A=>dosomething");
}
}
package com.mysoft.oop.demo09;
public class Application {
public static void main(String[] args) {
//new Action(); //error 抽象类不能被new
A a = new A();
a.dosomething();
a.hello();
}
}
接口
接口可以多继承
UserService.java
package com.mysoft.oop.demo10;
//抽象的思维 Java
//interface 定义的关键字，接口都需要有实现类
public interface UserService {
//常量 public static final（一般都是定义方法，定义常量的少）
int AGE = 99;
//接口中所有的定义其实都是抽象的 public abstract
//public abstract void add() ;
void add();
void delete();
void update();
void query();
}
TimeService.java
package com.mysoft.oop.demo10;
public interface TimeService {
void timer();
}
package com.mysoft.oop.demo10;
//抽象类： extends~
//类 可以实现接口 implements 接口
//实现了接口的类，就需要重写接口中的方法~
//多继承~ 利用接口实现多继承~
public class UserServiceImpl implements UserService, TimeService {
@Override
public void add() {
}
@Override
public void delete() {
}
@Override
public void update() {
}
@Override
public void query() {
}
@Override
public void timer() {
}
}
接口的作用：
作用：
1.约束
2.定义一些方法，让不同的人实现~ 10 --> 1
3.public abstract
4.public static final
5.接口不能被实例化~，接口中没有构造方法~
6.implements可以实现多个接口
7.必须要重写接口中的方法
内部类
了解就行
1.成员内部类
package com.mysoft.oop.demo11.sub01;
public class Outer {
private int id = 10;
public void out() {
System.out.println("这是外部类的方法");
}
class Inner{
public void in() {
System.out.println("这是内部类的方法");
}
//获得外部类的私有属性~
public void getID() {
System.out.println(id);
}
}
}
使用：
package com.mysoft.oop.demo11.sub01;
public class Application {
public static void main(String[] args) {
Outer outer = new Outer();
//通过这个外部类来实例化内部类
Outer.Inner inner = outer.new Inner();
inner.in();
inner.getID();
}
}
2.静态内部类 内部类定义时 使用了static
package com.mysoft.oop.demo11.sub01;
public class Outer2 {
private static int id = 10;
public void out() {
System.out.println("这是外部类的方法");
}
public static class Inner{
public void in() {
System.out.println("这是内部类的方法");
}
//获得外部类的私有属性~
public void getID() {
System.out.println(id);
}
}
}
3.局部内部类 在方法内部定义的类，属于局部
package com.mysoft.oop.demo11.sub04;
public class Outer {
//局部内部类
public void method() {
class Inner() {
public void in() {
}
}
}
}
4.匿名内部类
package com.mysoft.oop.demo11.sub03;
import com.mysoft.oop.demo09.A;
public class Test {
public static void main(String[] args) {
Apple apple = new Apple();
apple.eat();
//没有名字初始化类，不用将实例保存到变量中
new Apple().eat();
UserService userService = new UserService() {
@Override
public void hello() {
}
};
}
}
class Apple {
public void eat() {
System.out.println("1");
}
}
interface UserService {
void hello();
}
不是内部类，一个java文件里可以定义多个类，但只能有一个是public的
package com.mysoft.oop.demo11.sub02;
public class Outer {
}
//一个java文件中可以有多个class，但只能有一个是public的
class A {
public static void main(String[] args) {
}
}
经常用A这个类来写测试Outer类的测试类。
异常机制
什么是异常？ Exception
实际工作中遇到的情况不可能是非常完美的。
比如：你写的某个模块，用户输入不符合要求，你的程序要打开某个文件，这个文件不存在或者文件格式不对，
你要读取数据库的数据，数据可能为空等等。
跑程序时内存或硬盘满了，等等。
例如：StackOverflowError
Demo01.java
package com.exception.demo01;
public class Demo01 {
public static void main(String[] args) {
new Demo01().a();
}
public void a() {
b();
}
private void b() {
a();
}
}
ArithmeticException异常
package com.exception.demo01;
public class Demo02 {
public static void main(String[] args) {
int a = 2;
int b = 0;
System.out.println(a / b);
}
}
异常体系结构：
超类：java.lang.Thowable 作为所有异常类的超类
异常分为两类：错误Error 和 异常Exception
Error和Exception的区别：
异常处理机制
-
抛出异常
-
捕获异常
-
异常处理的五个关键字：try，catch，finally，throw， throws
package com.exception.demo01;
public class Test {
public static void main(String[] args) {
int a = 1;
int b = 0;
//假设要捕获多个异常：从小到大！
try {//try监控区域
//System.out.println(a / b);
new Test().a();
} catch (ArithmeticException e) {//catch(想要捕获的异常类型！) 捕获异常
System.out.println("程序出现异常，变量b不能为零");
} catch (Throwable t) {
System.out.println("throwable");
} finally {//处理善后工作
System.out.println("finally");
}
//finally 可以不要finally 假设IO，资源，关闭！
}
public void a() {
b();
}
private void b() {
a();
}
}
一个快捷键：
选中代码，然后 ctrl + alt + T
主动的抛出异常：
throw
Test2.java
package com.exception.demo01;
public class Test2 {
public static void main(String[] args) {
int a = 1;
int b = 0;
try {
if (b == 0) {//throw throws
throw new ArithmeticException();//主动的抛出异常
}
System.out.println(a / b);
} catch (Exception e) {
e.printStackTrace();
} finally {
}
}
}
更完全一点儿的例子，方法里抛出异常，然后在调用方法的地方可以捕获，进行处理。
Test3.java
package com.exception.demo01;
public class Test3 {
public static void main(String[] args) {
try {
new Test3().test(1, 0 );
} catch (ArithmeticException e) {
throw new RuntimeException(e);
}
}
//假设这个方法中，处理不了这个异常。方法上抛出异常
public void test(int a, int b) throws ArithmeticException {
if (b == 0) {
throw new ArithmeticException(); //主动的抛出异常，一般在方法中使用
}
System.out.println(a / b);
}
}
自定义异常
使用java内置的异常类可以描述编程时出现的大部分异常情况。
还可以自定义异常类，只需要继承Exception类即可。
自定义异常，大体一下几个步骤：
1.创建自定义异常类
2.在方法中通过throw关键字抛出异常对象。
3.如果在当前抛出异常的方法中处理异常，可以使用try-catch捕获并处理；
否则要在方法的声明处通过关键字throws指明要抛出给方法的调用者。
4.在出现异常方法的调用者中捕获并处理异常。
MyException.java
package com.exception.demo02;
//自定义的异常类
public class MyException extends Exception {
//传递数字 > 10
private int detail;
public MyException(int a) {
this.detail = a;
}
//toString:异常的打印信息
@Override
public String toString() {
return "MyException{" + "detail=" + detail + '}';
}
}
Test.java
package com.exception.demo02;
public class Test {
//可能会存在异常的方法
static void test(int a) throws MyException {
System.out.println("传递的参数为：" + a);
if (a > 10) {
throw new MyException(a);//抛出
}
System.out.println("OK");
}
public static void main(String[] args) {
try {
test(11);
} catch (MyException e) {
//throw new RuntimeException(e);
//e.printStackTrace();
System.out.println("MyException=>"+e );
}
}
}
输出结果为：
传递的参数为：11
MyException=>MyException{detail=11}
自定义异常，用的并没有那么多。
只需要了解一下就行，出现的时候能看懂就可以。
代码里有红色的波浪线，可以按住 Alt + Enter键，自动给你提示一些该怎么处理。
非常好用的万能键。
