JavaSE面向对象04 2021.05.19
Posted 碧咸加油
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了JavaSE面向对象04 2021.05.19相关的知识,希望对你有一定的参考价值。
答辩结束了啦,毕业典礼也结束啦,剩下的回校时间也不多啦,所以就没有理由不去学习啦,
keep going
static关键字详解
//static
public class Student {
private static int age;//静态变量 在多线程会用到
private double score;//非静态变量
public void run(){
}
public static void go(){
}
public static void main(String[] args) {
Student s1 = new Student();
Student.go();
System.out.println(age);
System.out.println(s1.score);
System.out.println(s1.age);
s1.run();
}
}
代码块
public class Person {
//2.赋初值
{
System.out.println("匿名代码块");//匿名代码块 在构造器之前 创建对象的时候就创建了
}
//1.第一个执行 与类一起加载
static {
System.out.println("静态代码块");//静态代码块 加载初始化数据,与类一起加载,只执行一次
}
//3.
public Person() {
System.out.println("构造器");
}
public static void main(String[] args) {
Person person1 = new Person();
Person person2 = new Person();
}
}
输出结果为:
静态代码块
匿名代码块
构造器
匿名代码块
构造器
public class Test {
public static void main(String[] args) {
System.out.println(Math.random());
System.out.println(Math.PI);
}
}
静态导入包后不用写类名
//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Test {
public static void main(String[] args) {
System.out.println(random());
System.out.println(PI);
}
}
类被final修饰后不能被继承
public final class Person {
public class Student extends Person {//标红
抽象类
抽象的抽象:约束
abstract修饰符可以用来修饰方法也可以修饰类
抽象类:类 extends:单继承
接口可以多继承
//abstract 抽象类
public abstract class Action {
//约束~有人帮我们实现
//abstract,抽象方法,只有方法名字,没有方法的实现
public abstract void go();
}
//继承了抽象类的子类,都必须要实现抽象类没有实现的抽象方法~除非这个子类也是抽象类
public class A extends Action{
@Override
public void go() {
}
}
public abstract class A extends Action{
}
特点:
- 不能new这个抽象类,只能靠子类去实现它:约束!
- 抽象类中可以写普通方法,抽象类中可以没有抽象方法
- 抽象方法必须在抽象类中
思考题:
1 抽象类存在构造器吗? 存在,在继承了抽象类的子类中通过super()或super(参数列表)调用抽象类中的构造方法来证明。
2 存在的意义:提高开发效率
接口
- 普通类:只有具体实现
- 抽象类:具体实现和规范(抽象方法)都有
- 接口:只有规范!自己无法写方法~专业的约束!约束和实现分离:面向接口编程
接口的本质是契约
OO的精髓,是对 对象的抽象,最能体现这一点的就是接口
声明类的关键字是class ,声明接口的关键字是interface
接口中的所有定义的方法都是 抽象的,都是默认为 public abstract
定义的属性都是 变量,都是默认为public static final
/*public static final */ int AGE =1;
/*public abstract */ void run();
接口都需要实现类,一般类名为 接口名+Impl
类可以实现接口,implements 接口
public class UserServiceImpl implements UserService{
}
实现了接口的类,就需要重写接口中的方法
利用接口实现多继承~
public interface UserService {
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
public interface TimeService {
void timer();
}
public class UserServiceImpl implements UserService,TimeService{
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
@Override
public void timer() {
}
}
作用:
- 约束
- 定义一些方法,让不同的人实现
- 方法默认 public abstract
- 属性默认 public static final
- 接口不能被实例化,接口中没有构造方法
- implements 可以实现多个接口
- 必须要重写接口中的方法
内部类
内部类就是在一个类的内部再定义一个类。比如,A类中定义一个B类,那么B类相对A类来说就称为内部类,而A类相对B类来说就是外部类。
- 成员内部类
public class Outer {
private int id=10;
public void out(){
System.out.println("外部类方法");
}
public class Inner{
public void in(){
System.out.println("内部类方法");
}
//获得外部类的私有属性
public void grtId(){
System.out.println(id);
}
}
}
public class Application {
public static void main(String[] args) {
Outer outer = new Outer();
//通过这个外部类来实例化内部类
Outer.Inner inner = outer.new Inner();
inner.in();//内部类方法
inner.grtId();//10
}
}
- 静态内部类
public class Outer {
private int id=10;
public void out(){
System.out.println("外部类方法");
}
public static class Inner{//静态内部类无法直接访问非静态的属性
public void in(){
System.out.println("内部类方法");
}
}
}
- 局部内部类
public class Outer {
public void method(){
class Inner{//局部内部类
public void in(){
}
}
}
}
- 匿名内部类
public class Test {
public static void main(String[] args) {
//没有名字初始化类,不用将实例保存到变量中
new Apple().eat();
/*UserService userService =*/ new UserService(){
@Override
public void hello() {
}
};
}
}
class Apple{
public void eat(){
System.out.println("1");
}
}
interface UserService{
void hello();
}
public class Outer {
}
//一个java类中可以有多个class类,但是只能有一个 public class
class A{
}
面向对象的思维思想
以上是关于JavaSE面向对象04 2021.05.19的主要内容,如果未能解决你的问题,请参考以下文章
JavaSE入门学习21:Java面向对象之接口(interface)